From 8e8eae5049a2c48ea88ea4be99a2d3da42e8c699 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 01:52:38 +0000 Subject: [PATCH 1/6] feat(packages): source packages, the registry rows, and the cases (Refs #161) A language-1.2 project declares [[source_package]] (kind path, a member of the workspace named by lexlean-workspace.toml), pinned in lexlean.lock by tree and manifest digest; imports are closed at link, a package definition is an ordinary definition of the importing project, and verify replays package modules with their origin in the records. Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- CONFORMANCE.md | 9 + ERRORS.md | 30 + README.md | 2 +- SPEC.md | 64 +- crates/conformance/src/cases/mod.rs | 2 + crates/conformance/src/cases/packages.rs | 704 +++++++++++++++++ crates/conformance/src/cases/repository.rs | 2 +- crates/conformance/src/support.rs | 24 + crates/conformance/tests/conformance.rs | 20 + crates/lexlean/src/api.rs | 33 +- crates/lexlean/src/artifact/manifest.rs | 11 +- crates/lexlean/src/artifact/snapshot.rs | 4 + crates/lexlean/src/backend/lean.rs | 10 +- crates/lexlean/src/backend/semantic.rs | 19 +- crates/lexlean/src/cli.rs | 1 + crates/lexlean/src/config.rs | 119 +++ crates/lexlean/src/ir/document.rs | 45 +- crates/lexlean/src/lib.rs | 2 + crates/lexlean/src/link.rs | 352 +++++++-- crates/lexlean/src/lock.rs | 130 +++ crates/lexlean/src/project.rs | 44 ++ crates/lexlean/src/source_package.rs | 743 ++++++++++++++++++ crates/lexlean/src/verify/mod.rs | 16 + features/suites/packages.feature | 31 + model/errors.toml | 35 + model/ids.toml | 24 + schemas/attestation-v2.schema.json | 2 +- schemas/build-manifest-v2.schema.json | 2 +- schemas/lock-v2.schema.json | 2 +- schemas/project-v2.schema.json | 2 +- schemas/semantic-snapshot-v2.schema.json | 2 +- .../packages/workspace/app/lake-manifest.json | 6 + tests/packages/workspace/app/lakefile.toml | 2 + tests/packages/workspace/app/lean-toolchain | 1 + tests/packages/workspace/app/lexlean.toml | 33 + tests/packages/workspace/app/src/Main.lex.tex | 22 + .../workspace/base/lake-manifest.json | 6 + tests/packages/workspace/base/lakefile.toml | 2 + tests/packages/workspace/base/lean-toolchain | 1 + tests/packages/workspace/base/lexlean.toml | 27 + .../packages/workspace/base/src/Core.lex.tex | 16 + .../packages/workspace/lexlean-workspace.toml | 2 + .../packages/workspace/lib/lake-manifest.json | 6 + tests/packages/workspace/lib/lakefile.toml | 2 + tests/packages/workspace/lib/lean-toolchain | 1 + tests/packages/workspace/lib/lexlean.toml | 33 + .../packages/workspace/lib/src/Shapes.lex.tex | 14 + tests/packages/workspace/lib/src/Util.lex.tex | 22 + xtask/src/spec_links.rs | 4 +- 49 files changed, 2604 insertions(+), 82 deletions(-) create mode 100644 crates/conformance/src/cases/packages.rs create mode 100644 crates/lexlean/src/source_package.rs create mode 100644 features/suites/packages.feature create mode 100644 tests/packages/workspace/app/lake-manifest.json create mode 100644 tests/packages/workspace/app/lakefile.toml create mode 100644 tests/packages/workspace/app/lean-toolchain create mode 100644 tests/packages/workspace/app/lexlean.toml create mode 100644 tests/packages/workspace/app/src/Main.lex.tex create mode 100644 tests/packages/workspace/base/lake-manifest.json create mode 100644 tests/packages/workspace/base/lakefile.toml create mode 100644 tests/packages/workspace/base/lean-toolchain create mode 100644 tests/packages/workspace/base/lexlean.toml create mode 100644 tests/packages/workspace/base/src/Core.lex.tex create mode 100644 tests/packages/workspace/lexlean-workspace.toml create mode 100644 tests/packages/workspace/lib/lake-manifest.json create mode 100644 tests/packages/workspace/lib/lakefile.toml create mode 100644 tests/packages/workspace/lib/lean-toolchain create mode 100644 tests/packages/workspace/lib/lexlean.toml create mode 100644 tests/packages/workspace/lib/src/Shapes.lex.tex create mode 100644 tests/packages/workspace/lib/src/Util.lex.tex diff --git a/CONFORMANCE.md b/CONFORMANCE.md index e0cf5693d..03b684841 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -321,6 +321,15 @@ the error registry does not sanction (R5, `ERRORS.md`). | `OR-07` | `build` | An oracle that was not acquired, whose checkout is not the pin, that did not build, that crashed, was killed, overran its time (and with it everything it started), wrote nothing or an IR defining nothing, or whose generator failed without refusing a program, a fetch that fails leaving nothing that a later run takes for a checkout, a cache that is not the pin discarded and fetched once more, a transient failure of the network tried again twice and a permanent one not, and a comparison over no root or no case, are each unavailable and never validated, which fails the gate on the normative host and is reported as not validated elsewhere, while the oracle's own structured refusals are answers and a tool that is not meant to overrun its time is given a generous one; and a disagreement fails closed with a record of both sides' evidence for every difference. | | `OR-08` | `build` | The oracle is validation evidence and an input to no identity: no file the shipped crate, the language data, the schemas, the compiler project, the committed examples' records, or the authority and ledger files hold names the oracle, its pinned commit, or its digest, so that planting any of them in any of those places fails audit-oracle-isolation; no input of the compiler-semantics ID names it, an oracle field in a build manifest, a preservation record, an attestation, a snapshot, a compiler input, or a GNAF certificate fails its closed schema, and no module of the conformance crate but the oracle's own uses it, so that removing it changes none of them. | +## packages + +| ID | Level | Statement | +| --- | --- | --- | +| `PK-01` | `build` | A language-1.2 project that declares a source package by its identifier, version, kind `path`, and the member directory a `lexlean-workspace.toml` lists locks it by the tree digest of its manifest and source files, its manifest digest, its version, its module prefix, and its own packages, and the configuration and the lock read back to the bytes written; a project without a source package keeps its bytes, and a package of another kind, a source package in another language, a changed byte or version (LLC0105), an undeclared package (LLC0106), a module prefix claimed twice (LLC0107), a project or a package outside the workspace (LLC0108), a path that escapes it, and a symlink (LLS8001) are each refused with the named code. | +| `PK-02` | `build` | A module of a project imports only modules of its own project and modules of the packages the project declares, and a module of a package only modules of itself and of the packages its own manifest declares: a package module is a module of the importing project under its own module prefix, a module of a package the project does not declare fails with LLR3009, and an import cycle through a package fails with LLR3003. | +| `PK-03` | `build` | An importing project builds and verifies under the pinned Lean offline, and its package modules are generated, elaborated, replayed with `leanchecker`, and audited for their exact axioms under the package's module prefix with the package as their origin in the records; the source ID of the project changes with the pins, and no file of the package is written by `fmt`, `build`, or `verify`. | +| `PK-04` | `build` | A production root of the importing project whose closure reaches a definition of a package certifies and exports over that closure as it does for a definition of its own module, the `production:` roots of a package are not roots of the importing project, and the importer publishes no certificate of the package's own. | + ## preservation | ID | Level | Statement | diff --git a/ERRORS.md b/ERRORS.md index 1117215ac..b12724992 100644 --- a/ERRORS.md +++ b/ERRORS.md @@ -88,6 +88,30 @@ Duplicate module or case-folded path collision. Class: `cli-configuration`. Exit code: 2. +## `LLC0105` --- Source package is not the package the lock pins + +A source package's version, source, module prefix, manifest digest, tree digest, or declared packages differ from the lock's row, naming the package and both digests. + +Class: `cli-configuration`. Exit code: 2. + +## `LLC0106` --- Source package undeclared or declared with two sources + +The lock pins a source package the project does not declare, or one identifier names two sources in the closure. + +Class: `cli-configuration`. Exit code: 2. + +## `LLC0107` --- Module prefix claimed by two sources + +A module prefix is claimed by the project and a source package, or by two source packages, equal or one beneath the other, or an import names a module both the project and a package provide. + +Class: `cli-configuration`. Exit code: 2. + +## `LLC0108` --- Source package outside the workspace rule + +A project that declares a source package is outside any workspace or is not a member of it, a package is not a member of the workspace, or the workspace file or a package is malformed. + +Class: `cli-configuration`. Exit code: 2. + ## `LLC0201` --- Production request malformed A production request is not a closed `lexlean/production-request/1` document: an unknown or missing field, another spec, roots, targets, or evidence that are empty, unsorted, or repeated, a root, package, or path that is not of its form, or a package name used twice for one target. @@ -256,6 +280,12 @@ Model artifact bytes violate the declared schema, type, or role. Class: `language`. Exit code: 1. +## `LLR3009` --- Import of a module of a source package the importing scope does not declare + +A module imports a module of a source package that the project, or the package the module belongs to, does not declare. + +Class: `language`. Exit code: 1. + ## `LLS8001` --- Path escape, symlink, special file, or filesystem identity conflict Path escape, symlink, special file, or filesystem identity conflict. diff --git a/README.md b/README.md index 9b53c9ab3..74e4e6b48 100644 --- a/README.md +++ b/README.md @@ -138,7 +138,7 @@ just vv # the complete normative acceptance gate (SPEC.md §9.2) just release # vv, then the §30 release criterion; refused until 1.0.0 ``` -All 392 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. +All 396 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. The differential against the independent generator `lean4-prod` (SPEC.md §17.19, `OR-01`..`OR-08`) acquires it at its pinned commit: from the checkout `LEXLEAN_ORACLE_DIR` names, or by fetching the commit with `git` into the Cargo target directory (`LEXLEAN_ORACLE_CACHE` overrides), and builds it with the pinned Lean and Rust toolchains. It is validation evidence only and no input to any identity. An oracle that cannot be acquired, is not the pinned files, or fails is unavailable: that fails the gate on Linux x86-64 and is printed as `NOT VALIDATED` elsewhere, and is never reported as agreement. diff --git a/SPEC.md b/SPEC.md index efffc4262..816c195e6 100644 --- a/SPEC.md +++ b/SPEC.md @@ -701,6 +701,7 @@ A LexLean project contains: - a valid Lake workspace; - one or more `.lex.tex` modules under configured source roots; - zero or more local lexicon packages; +- in language 1.2, zero or more source packages, member projects of the project's workspace that it imports modules from (§10.5); - `.lexlean/`, reserved for generated and verified artifacts. No project file may override the language grammar, backend, verifier sequence, axiom-audit parser, source-map format, or verified artifact set. @@ -746,10 +747,11 @@ The parsed project has one canonical TOML serialization used by `project_config_ 1. scalar top-level keys in the order shown by the schema example; 2. `lexicon_source` tables sorted by `package`, with keys in the order `package`, `kind`, then kind-specific fields; 3. language 1.2 only: `artifact_source` tables sorted by `sha256`, with keys in the order `sha256`, `path`, omitted entirely when there are none, so a project without artifacts keeps its bytes; -4. `[limits]` with keys in the order shown; -5. optional `[pdf]` last, with keys in the order shown; -6. basic quoted strings, decimal integers, arrays with comma-space separators, LF line endings, and one final LF; -7. no comments, blank leading lines, or trailing spaces. +4. language 1.2 only: `source_package` tables sorted by `package`, with keys in the order `package`, `version`, `kind`, `path`, omitted entirely when there are none, so a project without source packages keeps its bytes; +5. `[limits]` with keys in the order shown; +6. optional `[pdf]` last, with keys in the order shown; +7. basic quoted strings, decimal integers, arrays with comma-space separators, LF line endings, and one final LF; +8. no comments, blank leading lines, or trailing spaces. Input whitespace does not affect this canonical serialization. A project may be semantically valid before formatting, but `lexlean lock --check` and repository examples require canonical bytes. @@ -769,6 +771,7 @@ Input whitespace does not affect this canonical serialization. A project may be | `lean_toolchain` | Exactly the language-1.0 toolchain string. | | `lexicon_source` | Unique by package and sorted by package identifier. | | `artifact_source` | Language 1.2 only (another language rejects the field, `LLC0101`): optional `[[artifact_source]]` tables `sha256 = "<64 lowercase hex>"`, `path = ""`, sorted by `sha256`, unique by digest and by path, never beneath the build root. Each names the content-addressed bytes of one model artifact (§17.12); `check`, `build`, `fmt`, and `verify` read the file, confined (§25.1), and require its SHA-256 to equal the configured digest (`LLR3007`). Artifacts are never fetched. | +| `source_package` | Language 1.2 only (another language rejects the field, `LLC0101`): optional `[[source_package]]` tables `package = ""`, `version = ""`, `kind = "path"`, `path = ""`, sorted and unique by `package`, with `package` an identifier of the form of `name` and `version` a string of at most 64 ASCII letters, digits, `.`, `+`, and `-` that begins with a letter or digit. `path` is resolved from the workspace root, not the project's (§10.5); a kind other than `path` is `LLC0101`, and a path that is absolute or has a `..` segment escapes the workspace and is `LLS8001`. | | `limits` | Every listed positive integer is required. There are no hidden compiler defaults. | #### Lexicon-source forms @@ -846,6 +849,31 @@ The project `lean-toolchain` MUST contain the exact toolchain string. `lexlean l If both Lake configuration forms exist, locking fails. Verification requires the recorded files to match and requires all manifest dependencies to be locally available. +### 10.5 Source packages + +A language-1.2 project imports the modules of another project, a *source package*, without copying them. A source package is a project: its own `lexlean.toml` names its `module_prefix`, its `source_roots`, its language (1.2), and its own source packages, and `entrypoints` may name any of its modules, since a library has no distinguished one. Its modules keep its prefix: a module `Text` of a package whose prefix is `LexLeanStd` is the Lean module `LexLeanStd.Text` in every project that imports it. Nothing is fetched: a package is read from a directory of the workspace, `kind` is `path` and nothing else, and a package of any other kind is refused rather than treated as a later extension. + +**The workspace.** Until now every read of a project lay inside the project (§25.1). A package lives beside the projects that use it, so one widening is made, stated narrowly. An optional `lexlean-workspace.toml` at the root of a repository lists the member project directories: + +```toml +spec = "lexlean/workspace/1" +members = ["app", "base", "lib"] +``` + +`members` are unique, sorted, workspace-relative directories (no `..`, no leading separator), and the file carries no comment. The workspace of a project is the nearest proper ancestor of its canonical root that holds the file. A project that declares a source package must be a member of its workspace, and a `source_package` path must name a member, resolved from the workspace root. A project outside any workspace, a project its workspace does not list, a path that names no member, and a malformed workspace file are `LLC0108`: a stray file higher in the tree grants nothing to a project it does not list. No path component from the workspace root to a package may be a symlink, and a path with a `..` segment is an escape; both are `LLS8001`. Of a package, only its `lexlean.toml` and the files beneath its `source_roots` are read, and a symlink or a special file among them is `LLS8001`. A project that declares no source package reads nothing outside its own root, and has no workspace. + +**The manifest of a package** declares language 1.2, no `artifact_source`, no `[pdf]`, and only builtin `lexicon_source`s: those would read files outside what the pin covers, or glossaries the importing project does not have. A violation is `LLC0101`. The glossaries a package module uses (`\useglossary`) are resolved in the closure of the importing project, so a package that uses one the project does not load fails `LLR3001`. + +**The pin.** `lexlean.lock` (§11) carries one `[[source_package]]` row for every package in the transitive closure of the project's declarations, sorted by `id`: the identifier, the declared `version`, `kind`, the workspace-relative `source`, the package's `module_prefix`, `tree_sha256` over the package's `lexlean.toml` and every regular file beneath its `source_roots` (the tree digest of §11.5, over package-relative paths in bytewise order), `manifest_sha256` over its `lexlean.toml`, and `imports`, the `id@version` of the packages its own manifest declares, sorted. The digests are recomputed by every command: `lock --check`, `check`, `fmt`, `build`, and `verify` read the package and require the lock's row to be the package as it now is. A changed byte, a changed version, source, prefix, or declared package is `LLC0105`, naming the package and the locked and the found values, before anything is linked. A row for a package the closure of the project's declarations does not reach is `LLC0106`, and so is one identifier with two sources. `lexlean lock` writes the rows, and a package that depends on itself or on the importing project is `LLR3003`. + +**One source per module prefix.** The importing project's prefix and each package's must not be equal, and none may lie beneath another (`a.b` is beneath `a`); two sources that claim a prefix are `LLC0107`. + +**Closed imports.** A module of the importing project may import modules of the project, written as before, and modules of the packages the project declares itself, written with the package's prefix: `\importmodule{LexLeanStd.Text}`. A module of a package may import the modules of that package, written as inside the package, and the modules of the packages its own manifest declares, written with their prefixes. A module of a package the importing scope does not declare, though the closure holds it, is `LLR3009`; one no source provides is `LLR3005`; a name both the scope's own modules and a declared package provide is `LLC0107`; a cycle of packages or of modules is `LLR3003`. The package's modules that no import reaches are not linked. Inside the linked project a package module is named by its Lean name, `LexLeanStd.Text`, which is its key in every record; its references to a sibling are read under that key. + +**Production.** A package's `production:` clauses make roots of the package project, built when the package is built. Imported by another project, a package definition is an ordinary definition: no module of a package is analysed for production roots, the certificates are those of the closure of the importing project's roots, and the package's own certified roots are not republished by the importer. There is no re-export. + +**Verification and identity.** The modules of every package the project reaches are generated, elaborated, replayed with `leanchecker`, and audited as part of the importing project's `verify`, under the package's prefix. The build manifest's module rows, the semantic snapshot's modules, and the attestation (`origins`, by Lean module) name the package as their `origin`; the document of a package module is linked and rendered like any other, and `fmt` never rewrites a package file, which is the package's own. Nothing crosses runs (§9.4): there is no cache of a built package. The source ID (§21.3) hashes the canonical lock, and so the pins, and the bytes of every linked package module. `source_package` and the lock rows are part of the language-1.2 schemas, so they move the language-1.2 compiler-semantics ID (§21.2) once; languages 1.0 and 1.1 are unchanged, and so is a language-1.2 project that declares no source package, apart from that identity. + --- ## 11. Lock file @@ -890,6 +918,20 @@ imports = ["lexlean.core@1.0.0"] An optional `[pdf]` lock record mirrors the configured provider and records the hashes of every declared resource. +Language 1.2 only, a project that declares source packages (§10.5) has, after the `[[package]]` rows, one `[[source_package]]` row for every package in the transitive closure of its declarations, and a project that declares none has none: + +```toml +[[source_package]] +id = "lib" +version = "1.0.0" +kind = "path" +source = "lib" +module_prefix = "PkgLib" +tree_sha256 = "..." +manifest_sha256 = "..." +imports = ["base@1.0.0"] +``` + Language-1.2 model artifacts (§10.1, §17.12) have no lock rows: each is pinned by its `sha256` in `lexlean.toml`, whose canonical bytes the lock's project digest and the source ID cover, and every `check`, `build`, `fmt`, and @@ -899,6 +941,7 @@ digest and the source ID cover, and every `check`, `build`, `fmt`, and - `workspace_file` rows sort by `path`. - `package` rows sort by `(id, version)`. +- `source_package` rows sort by `id`, and their `imports` by `id`. - package `imports` sort lexicographically and contain no duplicates. - all keys use the order shown by the schema formatter. - lowercase hexadecimal is mandatory. @@ -8130,7 +8173,7 @@ LexLean: - canonicalizes the project root once; - rejects non-UTF-8 logical paths; -- rejects symlinks in source roots, lexicon packages, lock inputs, build roots, and declared PDF resources; +- rejects symlinks in source roots, lexicon packages, source packages (§10.5), lock inputs, build roots, and declared PDF resources; - rejects any normalized `..` escape; - rejects duplicate files by filesystem identity; - detects case-fold collisions before output; @@ -8231,6 +8274,10 @@ The initial registry MUST include at least these exact codes and meanings: | `LLC0102` | Missing, stale, or noncanonical lock file. | | `LLC0103` | Unsupported schema or language version. | | `LLC0104` | Duplicate module or case-folded path collision. | +| `LLC0105` | Source package is not the package the lock pins (§10.5). | +| `LLC0106` | Source package undeclared, or declared with two sources (§10.5). | +| `LLC0107` | Module prefix claimed by two sources (§10.5). | +| `LLC0108` | Source package outside the workspace rule (§10.5). | | `LLC0201` | Production request malformed (§24.7). | | `LLC0202` | Requested root is not a production root (§24.7). | | `LLC0203` | Unknown or mismatched production target (§24.7). | @@ -8253,6 +8300,7 @@ The initial registry MUST include at least these exact codes and meanings: | `LLR3006` | Unsafe canonical form or raw renderer output. | | `LLR3007` | Model artifact unavailable or its digest or length mismatched (§10.1, §17.12). | | `LLR3008` | Model artifact bytes violate the declared schema, type, or role (§17.12). | +| `LLR3009` | Import of a module of a source package the importing scope does not declare (§10.5). | | `LLT4001` | Arity, binder, category, or conservative type mismatch. | | `LLT4002` | Unresolved overloaded entry. | | `LLT4003` | External-interface probe mismatch. | @@ -9375,8 +9423,12 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `RT-02` | `runtime` | The runtime text of languages 1.0 and 1.1 is the one declared exception: the portable runtime and the decoder of core module 1 are the released bytes, held as data under `language/runtime-1.2/frozen/`, read by the language-1.0 and 1.1 backends alone, excluded from the language-1.0 and 1.1 identities, and reproduced byte for byte by the released language-1.1 and 1.0 output; a one-byte change of either is not the released output. | §17.12, §21.2 | | `RT-03` | `runtime` | A verification compiles every runtime module that a project's generated modules, or the calculus modules its certificates are checked against, import before the project's modules, replays it with `leanchecker`, and audits each of its declarations against the axioms its row pins; the committed verification of a project that uses the collections prints them, the runtime's own project verifies under the pinned Lean, and a row that pins another axiom set than its declaration observes fails with LLV7005. | §17.12, §22.3, §22.5, §22.6 | | `RT-04` | `runtime` | No Lean runtime text remains in the language-1.2 compiler: a generated language-1.2 module imports the runtime modules whose constants it names and declares nothing under a runtime namespace, and the only Lean runtime text in the compiler's source outside unit-test items, in one string literal or in several written together, is the decoder of core module 2, which loads native modules and so cannot be one; a runtime text planted in any of its shapes, raw or escaped, with or without a namespace line, split across literals, or after a test module, is found. | §17.12, §18.1 | +| `PK-01` | `packages` | A language-1.2 project that declares a source package by its identifier, version, kind `path`, and the member directory a `lexlean-workspace.toml` lists locks it by the tree digest of its manifest and source files, its manifest digest, its version, its module prefix, and its own packages, and the configuration and the lock read back to the bytes written; a project without a source package keeps its bytes, and a package of another kind, a source package in another language, a changed byte or version (LLC0105), an undeclared package (LLC0106), a module prefix claimed twice (LLC0107), a project or a package outside the workspace (LLC0108), a path that escapes it, and a symlink (LLS8001) are each refused with the named code. | §10.5, §11.1, §25.1 | +| `PK-02` | `packages` | A module of a project imports only modules of its own project and modules of the packages the project declares, and a module of a package only modules of itself and of the packages its own manifest declares: a package module is a module of the importing project under its own module prefix, a module of a package the project does not declare fails with LLR3009, and an import cycle through a package fails with LLR3003. | §10.5, §15.1 | +| `PK-03` | `packages` | An importing project builds and verifies under the pinned Lean offline, and its package modules are generated, elaborated, replayed with `leanchecker`, and audited for their exact axioms under the package's module prefix with the package as their origin in the records; the source ID of the project changes with the pins, and no file of the package is written by `fmt`, `build`, or `verify`. | §10.5, §21.3, §22 | +| `PK-04` | `packages` | A production root of the importing project whose closure reaches a definition of a package certifies and exports over that closure as it does for a definition of its own module, the `production:` roots of a package are not roots of the importing project, and the importer publishes no certificate of the package's own. | §10.5, §17.13 | -**Total required capability IDs:** 392. +**Total required capability IDs:** 396. No row may be downgraded to `some-true` or `open`. Upstream Lean facts are ledger/authority rows, not substitutions for these build behaviors. diff --git a/crates/conformance/src/cases/mod.rs b/crates/conformance/src/cases/mod.rs index c08864b78..8b3b154b2 100644 --- a/crates/conformance/src/cases/mod.rs +++ b/crates/conformance/src/cases/mod.rs @@ -25,6 +25,7 @@ mod lexicon; mod models; mod operational; mod oracle; +mod packages; mod preservation; mod production; mod production_export; @@ -114,6 +115,7 @@ pub fn run(id: &str) { "RT" => runtime::run(id), "TL" => tooling::run(id), "AU" => authoring::run(id), + "PK" => packages::run(id), _ => panic!("no conformance case is wired for {id}"), } } diff --git a/crates/conformance/src/cases/packages.rs b/crates/conformance/src/cases/packages.rs new file mode 100644 index 000000000..dce945777 --- /dev/null +++ b/crates/conformance/src/cases/packages.rs @@ -0,0 +1,704 @@ +//! The `packages` suite: PK-01..PK-04, source packages (SPEC.md §10.5): a +//! language-1.2 project imports the modules of a locked, content-addressed +//! package of its workspace. + +use lexlean::{Engine, LexLeanError, LockRequest}; + +use crate::production_consumer::{AppRoot, Application}; +use crate::support::{self, P}; + +/// Run the case for one `PK` ID. +/// +/// # Panics +/// +/// Panics when the case's assertion fails. +pub fn run(id: &str) { + match id { + "PK-01" => pk_01(), + "PK-02" => pk_02(), + "PK-03" => pk_03(), + "PK-04" => pk_04(), + _ => panic!("no packages case is wired for {id}"), + } +} + +/// Edit one occurrence in a file of the copy by its own bytes: `P::edit` reads +/// a `.lex.tex` file in its data form, which would rewrite the notation. +fn edit_raw(project: &P, relative: &str, from: &str, to: &str) { + let path = project.root.join(relative); + let text = std::fs::read_to_string(path.as_std_path()).expect("read"); + assert!(text.contains(from), "{relative} does not contain {from:?}"); + std::fs::write(path.as_std_path(), text.replacen(from, to, 1)).expect("write"); +} + +fn lock_request(check_only: bool) -> LockRequest { + LockRequest { + check_only, + allow_network: false, + } +} + +/// The first failure of loading the project, then `lock --check`, then +/// `check`: the stage a refusal surfaces in is not what these cases pin, the +/// code is. +fn first_error(project: &P) -> LexLeanError { + let engine = match Engine::load(&project.root.join("lexlean.toml")) { + Ok(engine) => engine, + Err(error) => return error, + }; + if let Err(error) = engine.lock(lock_request(true)) { + return error; + } + match engine.check(lexlean::CheckRequest { + selection: lexlean::Selection::Entrypoints, + }) { + Ok(_) => panic!("the project is refused"), + Err(error) => error, + } +} + +fn refused(project: &P, code: &str) -> LexLeanError { + let error = first_error(project); + support::expect_code(&error, code); + // Refused before any backend runs: nothing is built or verified. + for output in [".lexlean/build", ".lexlean/verified"] { + assert!( + !project.root.join(output).as_std_path().exists(), + "{code}: `{output}` was published" + ); + } + error +} + +fn lock_text(project: &P) -> String { + project.read_raw("lexlean.lock") +} + +/// The digest a lock row of `id` carries in `field`. +fn locked(lock: &str, id: &str, field: &str) -> String { + let row = lock + .split("[[source_package]]") + .skip(1) + .find(|row| row.contains(&format!("id = \"{id}\"\n"))) + .unwrap_or_else(|| panic!("the lock has a row for `{id}`")); + let prefix = format!("{field} = \""); + let value = row + .lines() + .find_map(|line| line.strip_prefix(prefix.as_str())) + .unwrap_or_else(|| panic!("the row of `{id}` has `{field}`")); + value.trim_end_matches('"').to_owned() +} + +fn modules_of(project: &P) -> Vec { + support::checked_project(project) + .modules + .keys() + .cloned() + .collect() +} + +/// PK-01: configuration, lock, workspace, and the refusals. +#[allow(clippy::too_many_lines)] +fn pk_01() { + // The configuration and the lock read back to the bytes written. + let app = P::package_workspace("app"); + app.relock(); + let lock = lock_text(&app); + assert!(lock.starts_with("spec = \"lexlean/lock/2\"\n")); + let base_row = "[[source_package]]\nid = \"base\"\nversion = \"1.0.0\"\nkind = \"path\"\nsource = \"base\"\nmodule_prefix = \"PkgBase\"\n"; + let lib_row = "[[source_package]]\nid = \"lib\"\nversion = \"1.0.0\"\nkind = \"path\"\nsource = \"lib\"\nmodule_prefix = \"PkgLib\"\n"; + assert!(lock.contains(base_row), "{lock}"); + assert!(lock.contains(lib_row), "{lock}"); + assert!( + lock.find(base_row) < lock.find(lib_row), + "rows are sorted by id" + ); + assert!(lock.contains("imports = []\n")); + assert!(lock.contains("imports = [\"base@1.0.0\"]\n")); + for id in ["base", "lib"] { + for field in ["tree_sha256", "manifest_sha256"] { + assert_eq!(locked(&lock, id, field).len(), 64, "{id} {field}"); + } + } + let engine = app.engine(); + engine + .lock(lock_request(true)) + .expect("lock --check accepts the lock it wrote"); + engine.lock(lock_request(false)).expect("lock again"); + assert_eq!(lock, lock_text(&app), "locking again writes the same bytes"); + let config = + lexlean::config::parse_project("lexlean.toml", app.read_raw("lexlean.toml").as_bytes()) + .expect("the configuration parses"); + assert_eq!(config.source_packages.len(), 1); + assert_eq!( + config.canonical_toml(), + app.read_raw("lexlean.toml"), + "the configuration is its own canonical serialization" + ); + let tree = locked(&lock, "lib", "tree_sha256"); + // The pin is of the package's bytes alone: the same package in another + // workspace copy has the same digest. + let other = P::package_workspace("app"); + other.relock(); + assert_eq!(tree, locked(&lock_text(&other), "lib", "tree_sha256")); + + // A project without a source package keeps its bytes (§10.1). + let example = P::example(); + assert!(!lock_text(&example).contains("source_package")); + assert_eq!( + example.read_raw("lexlean.lock"), + std::fs::read_to_string( + support::repo_root() + .join("examples/nat-add-zero/lexlean.lock") + .as_std_path() + ) + .expect("committed lock"), + "a language-1.0 project locks to the bytes it locked to before" + ); + example.relock(); + assert!(!lock_text(&example).contains("source_package")); + + // A changed byte of the package: the locked and the observed digests are + // both named. + let tampered = P::package_workspace("app"); + tampered.relock(); + let before = lock_text(&tampered); + edit_raw( + &tampered, + "../base/src/Core.lex.tex", + "name: twice_two,", + "name: twice_twoo,", + ); + let error = refused(&tampered, "LLC0105"); + let message = error.to_string(); + let locked_digest = locked(&before, "base", "tree_sha256"); + assert!(message.contains("`base`"), "{message}"); + assert!(message.contains(&locked_digest), "{message}"); + tampered.relock(); + let observed = locked(&lock_text(&tampered), "base", "tree_sha256"); + assert_ne!(observed, locked_digest); + assert!(message.contains(&observed), "{message}"); + + // The same bytes for a changed manifest of the package. + let manifest = P::package_workspace("app"); + manifest.relock(); + edit_raw( + &manifest, + "../base/lexlean.toml", + "name = \"base\"", + "name = \"basis\"", + ); + refused(&manifest, "LLC0105"); + + // A changed version, in the declaration. + let version = P::package_workspace("app"); + version.relock(); + edit_raw( + &version, + "lexlean.toml", + "version = \"1.0.0\"", + "version = \"1.0.1\"", + ); + let error = refused(&version, "LLC0105"); + assert!(error.to_string().contains("1.0.1"), "{error}"); + + // An undeclared package: the lock names one the configuration does not. + let undeclared = P::package_workspace("app"); + undeclared.relock(); + edit_raw( + &undeclared, + "lexlean.toml", + "[[source_package]]\npackage = \"lib\"\nversion = \"1.0.0\"\nkind = \"path\"\npath = \"lib\"\n\n", + "", + ); + refused(&undeclared, "LLC0106"); + + // One identifier with two sources. + let split = P::package_workspace("app"); + edit_raw( + &split, + "../lib/lexlean.toml", + "path = \"base\"", + "path = \"lib\"", + ); + edit_raw( + &split, + "lexlean.toml", + "package = \"lib\"", + "package = \"lib\"", + ); + let split_error = Engine::load(&split.root.join("lexlean.toml")) + .ok() + .and_then(|engine| engine.lock(lock_request(false)).err()) + .expect("the lock is refused"); + assert!( + split_error + .diagnostics + .iter() + .any(|d| d.code.as_str() == "LLC0106" || d.code.as_str() == "LLR3003"), + "{split_error}" + ); + + // A module prefix claimed by two sources. + let prefix = P::package_workspace("app"); + edit_raw( + &prefix, + "../base/lexlean.toml", + "module_prefix = \"PkgBase\"", + "module_prefix = \"PkgLib\"", + ); + let error = Engine::load(&prefix.root.join("lexlean.toml")) + .expect("loads") + .lock(lock_request(false)) + .err() + .expect("two sources claim PkgLib"); + support::expect_code(&error, "LLC0107"); + let own = P::package_workspace("app"); + edit_raw( + &own, + "lexlean.toml", + "module_prefix = \"PkgApp\"", + "module_prefix = \"PkgLib.Sub\"", + ); + let error = Engine::load(&own.root.join("lexlean.toml")) + .expect("loads") + .lock(lock_request(false)) + .err() + .expect("the project's prefix lies below a package's"); + support::expect_code(&error, "LLC0107"); + + // A path that is not a member, a project that is not a member, and no + // workspace at all. + let stranger = P::package_workspace("app"); + edit_raw( + &stranger, + "lexlean.toml", + "path = \"lib\"", + "path = \"other\"", + ); + refused(&stranger, "LLC0108"); + let not_member = P::package_workspace("app"); + std::fs::write( + not_member + .workspace_dir() + .join("lexlean-workspace.toml") + .as_std_path(), + "spec = \"lexlean/workspace/1\"\nmembers = [\"base\", \"lib\"]\n", + ) + .expect("write"); + refused(¬_member, "LLC0108"); + let outside = P::package_workspace("app"); + std::fs::remove_file( + outside + .workspace_dir() + .join("lexlean-workspace.toml") + .as_std_path(), + ) + .expect("remove"); + refused(&outside, "LLC0108"); + let malformed = P::package_workspace("app"); + std::fs::write( + malformed + .workspace_dir() + .join("lexlean-workspace.toml") + .as_std_path(), + "spec = \"lexlean/workspace/1\"\nmembers = [\"lib\", \"base\"]\n", + ) + .expect("write"); + refused(&malformed, "LLC0108"); + + // A path that escapes the workspace, and a symlink. + let escaping = P::package_workspace("app"); + edit_raw( + &escaping, + "lexlean.toml", + "path = \"lib\"", + "path = \"../lib\"", + ); + refused(&escaping, "LLS8001"); + let absolute = P::package_workspace("app"); + edit_raw( + &absolute, + "lexlean.toml", + "path = \"lib\"", + "path = \"/lib\"", + ); + refused(&absolute, "LLS8001"); + if cfg!(unix) { + let linked = P::package_workspace("app"); + let workspace = linked.workspace_dir(); + std::fs::rename( + workspace.join("lib").as_std_path(), + workspace.join("lib-real").as_std_path(), + ) + .expect("rename"); + support::symlink_any(workspace.join("lib-real"), workspace.join("lib")); + refused(&linked, "LLS8001"); + let inner = P::package_workspace("app"); + let source = inner.workspace_dir().join("base/src"); + std::fs::rename( + source.as_std_path(), + inner.workspace_dir().join("base/src-real").as_std_path(), + ) + .expect("rename"); + support::symlink_any(inner.workspace_dir().join("base/src-real"), source); + refused(&inner, "LLS8001"); + } + + // Other kinds and other languages are refused, not accepted. + let git = P::package_workspace("app"); + edit_raw( + &git, + "lexlean.toml", + "kind = \"path\"\npath = \"lib\"", + "kind = \"git\"\npath = \"lib\"", + ); + refused(&git, "LLC0101"); + let language = P::package_workspace("app"); + edit_raw( + &language, + "lexlean.toml", + "language = \"1.2\"", + "language = \"1.1\"", + ); + refused(&language, "LLC0101"); + let unsorted = P::package_workspace("app"); + edit_raw( + &unsorted, + "lexlean.toml", + "\n[limits]", + "\n[[source_package]]\npackage = \"base\"\nversion = \"1.0.0\"\nkind = \"path\"\npath = \"base\"\n\n[limits]", + ); + refused(&unsorted, "LLC0101"); + // A package may declare no model artifact, no PDF provider, and no + // lexicon source but a builtin one: those would read outside what the + // pin covers. + let artifact = P::package_workspace("app"); + edit_raw( + &artifact, + "../base/lexlean.toml", + "\n[limits]", + "\n[[artifact_source]]\nsha256 = \"0000000000000000000000000000000000000000000000000000000000000000\"\npath = \"artifact.bin\"\n\n[limits]", + ); + refused(&artifact, "LLC0101"); +} + +/// PK-02: the import closure at link. +fn pk_02() { + let app = P::package_workspace("app"); + app.relock(); + app.check_ok(); + let modules = modules_of(&app); + assert_eq!( + modules, + ["Main", "PkgBase.Core", "PkgLib.Shapes", "PkgLib.Util"], + "package modules are modules of the importing project under their own prefix" + ); + let checked = support::checked_project(&app); + for (name, lean) in [ + ("Main", "PkgApp.Main"), + ("PkgBase.Core", "PkgBase.Core"), + ("PkgLib.Shapes", "PkgLib.Shapes"), + ("PkgLib.Util", "PkgLib.Util"), + ] { + assert_eq!(checked.modules[name].document.lean_module, lean); + } + // Inside a package a module keeps its relative import of a sibling and + // names a module of a package its manifest declares by that package's + // prefix. + assert_eq!( + checked.modules["PkgLib.Util"].document.imports, + ["PkgLib.Shapes"] + ); + assert_eq!( + checked.modules["PkgLib.Shapes"].document.imports, + ["PkgBase.Core"] + ); + + // A module of a package the project does not declare, though the + // closure holds it. + let transitive = P::package_workspace("app"); + edit_raw( + &transitive, + "src/Main.lex.tex", + "\\importmodule{PkgLib.Util}\n", + "\\importmodule{PkgBase.Core}\n\\importmodule{PkgLib.Util}\n", + ); + transitive.relock(); + transitive.check_fails_with("LLR3009"); + + // The same for a module of a package: `base` does not declare `lib`. + let inward = P::package_workspace("app"); + edit_raw( + &inward, + "../base/src/Core.lex.tex", + "\\title{Natural number addition}", + "\\importmodule{PkgLib.Util}\n\\title{Natural number addition}", + ); + inward.relock(); + inward.check_fails_with("LLR3009"); + + // A module no source provides keeps the existing refusal. + let unknown = P::package_workspace("app"); + edit_raw( + &unknown, + "src/Main.lex.tex", + "\\importmodule{PkgLib.Util}\n", + "\\importmodule{PkgLib.Util}\n\\importmodule{PkgLib.Missing}\n", + ); + unknown.relock(); + unknown.check_fails_with("LLR3005"); + + // A name both the project and a package provide. + let both = P::package_workspace("app"); + both.write( + "src/PkgLib/Util.lex.tex", + &std::fs::read_to_string( + both.workspace_dir() + .join("lib/src/Util.lex.tex") + .as_std_path(), + ) + .expect("read") + .replace("\\begin{lexlean}{Util}", "\\begin{lexlean}{PkgLib.Util}") + .replace("\\importmodule{Shapes}\n", ""), + ); + both.relock(); + both.check_fails_with("LLC0107"); + + // A cycle through a package. + let cycle = P::package_workspace("app"); + edit_raw( + &cycle, + "../base/lexlean.toml", + "\n[limits]", + "\n[[source_package]]\npackage = \"lib\"\nversion = \"1.0.0\"\nkind = \"path\"\npath = \"lib\"\n\n[limits]", + ); + let error = Engine::load(&cycle.root.join("lexlean.toml")) + .expect("loads") + .lock(lock_request(false)) + .err() + .expect("the packages depend on each other"); + support::expect_code(&error, "LLR3003"); + + // A package is read through its own configuration: a change of its + // entrypoints or of a module no import reaches changes the pin, but only + // the modules imported are linked. + let spare = P::package_workspace("app"); + spare.write( + "../lib/src/Spare.lex.tex", + "\\begin{lexlean}{Spare}\n\\title{Spare}\n\\end{lexlean}\n", + ); + spare.relock(); + assert_eq!(modules_of(&spare), modules); +} + +/// PK-03: an importing project builds, verifies, and records the origin. +fn pk_03() { + let app = P::package_workspace("app"); + app.relock(); + // Formatting never writes a package file, and the formatted project is + // already canonical. + let before = package_bytes(&app); + let formatted = app + .engine() + .format(lexlean::FormatRequest { + selection: lexlean::Selection::Entrypoints, + check_only: false, + }) + .expect("fmt"); + assert_eq!( + formatted.units.keys().cloned().collect::>(), + ["Main"], + "only the project's own modules are formatted" + ); + assert_eq!(before, package_bytes(&app), "fmt wrote no package file"); + app.fmt_check_ok(); + let built = app.build_ok(); + let source_id = built.source_id; + let build_dir = app.build_dir(&built.build_id.expect("a build ID")); + for module in [ + "PkgApp/Main", + "PkgBase/Core", + "PkgLib/Shapes", + "PkgLib/Util", + ] { + assert!( + build_dir.join(format!("modules/{module}.lean")).is_file(), + "{module}" + ); + } + let manifest = + std::fs::read_to_string(build_dir.join("manifest.json").as_std_path()).expect("manifest"); + assert!(manifest.contains("\"origin\":\"lib\""), "{manifest}"); + assert!(manifest.contains("\"origin\":\"base\""), "{manifest}"); + assert_eq!(manifest.matches("\"origin\"").count(), 3); + + // The source ID follows the pins: a byte of the package moves it once + // the lock is rewritten, and no run reads the changed package before. + let moved = P::package_workspace("app"); + moved.relock(); + edit_raw( + &moved, + "../base/src/Core.lex.tex", + "name: twice_two,", + "name: twice_twoo,", + ); + moved.verify_fails_with("LLC0105"); + moved.assert_no_backend_output_with("LLC0105"); + moved.relock(); + let relocked = moved.check_ok(); + assert_ne!( + relocked.source_id, source_id, + "the source ID follows the pins" + ); + + if !support::lean_backed("PK-03") { + return; + } + let _environment = support::env_shared(); + let verified = support::verify_ok(&app); + assert_eq!( + verified.units.keys().cloned().collect::>(), + ["Main", "PkgBase.Core", "PkgLib.Shapes", "PkgLib.Util"] + ); + assert_eq!(verified.units["PkgLib.Util"].lean_module, "PkgLib.Util"); + // Every module is replayed and audited, the package modules under their + // own prefix and with their origin in the records. + let verified_dir = app + .root + .join(".lexlean/verified") + .join(verified.attestation_id.to_hex()); + let attestation: serde_json::Value = serde_json::from_slice( + &std::fs::read(verified_dir.join("attestation.json").as_std_path()).expect("attestation"), + ) + .expect("the attestation is JSON"); + let processes = attestation["processes"].as_array().expect("processes"); + for module in [ + "PkgApp.Main", + "PkgBase.Core", + "PkgLib.Shapes", + "PkgLib.Util", + ] { + for tool in ["lean", "leanchecker"] { + assert!( + processes.iter().any(|process| { + process["module"] == module + && process["argv"].as_array().is_some_and(|argv| { + argv.iter().any(|a| { + a.as_str() + .is_some_and(|a| a == tool || a.ends_with(&format!("/{tool}"))) + }) + }) + }), + "`{module}` is run through `{tool}`" + ); + } + } + let declarations: Vec<&str> = attestation["declarations"] + .as_array() + .expect("declarations") + .iter() + .filter_map(|row| row["name"].as_str()) + .collect(); + for name in [ + "PkgBase.Core.twice", + "PkgBase.Core.twice_two", + "PkgLib.Shapes.quad", + "PkgLib.Util.quadPlusOne", + "PkgApp.Main.appValue", + ] { + assert!(declarations.contains(&name), "`{name}` is audited"); + } + assert_eq!( + attestation["origins"], + serde_json::json!({ + "PkgBase.Core": "base", + "PkgLib.Shapes": "lib", + "PkgLib.Util": "lib" + }), + "the modules of a package carry the package as their origin" + ); + assert_eq!(before, package_bytes(&app), "verify wrote no package file"); +} + +/// The bytes of every file of the packages beside the project. +fn package_bytes(project: &P) -> Vec<(String, Vec)> { + let mut files = Vec::new(); + for member in ["base", "lib"] { + for entry in walkdir::WalkDir::new(project.workspace_dir().join(member).as_std_path()) + .sort_by_file_name() + .into_iter() + .flatten() + .filter(|entry| entry.file_type().is_file()) + { + files.push(( + entry.path().to_string_lossy().into_owned(), + std::fs::read(entry.path()).expect("read"), + )); + } + } + files +} + +/// PK-04: a production root reaches a package definition. +fn pk_04() { + let app = P::package_workspace("app"); + app.relock(); + let checked = support::checked_project(&app); + for (name, module) in &checked.modules { + assert_eq!( + module.production.is_some(), + name == "Main", + "`{name}`: only the importing project's own roots are analysed" + ); + } + let roots = lexlean::production::lower::roots(&checked).expect("roots"); + assert_eq!( + roots + .iter() + .map(|root| root.report.root.clone()) + .collect::>(), + ["PkgApp.Main.appValue"], + "a package's own roots are not roots of the importing project" + ); + // The closure of the root includes the definitions of both packages. + let program = crate::production_export::lowered_program(&app, "PkgApp.Main.appValue"); + let rendered = format!("{program:?}"); + assert!(!rendered.is_empty()); + + if !support::lean_backed("PK-04") { + return; + } + let _environment = support::env_shared(); + let application = Application { + roots: vec![AppRoot { + root: "PkgApp.Main.appValue".to_owned(), + name: "app_value".to_owned(), + version: "1.0.0".to_owned(), + targets: vec!["rust-std".to_owned()], + }], + }; + let (output, report) = + crate::production_consumer::export(&app.root.join("lexlean.toml"), &application, &[]) + .expect("the root certifies and exports"); + let _ = report; + assert_eq!( + output + .result + .roots + .iter() + .map(|root| root.root.clone()) + .collect::>(), + ["PkgApp.Main.appValue"], + "the export holds the importing project's root alone" + ); + let bundle = app.root.join(&output.bundle); + let files = crate::production_export::tree(&bundle); + assert!( + files + .keys() + .all(|path| !path.contains("PkgBase") && !path.contains("PkgLib")), + "no certificate of the package's own roots is published: {:?}", + files.keys().collect::>() + ); +} diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 974c44981..fd46efed5 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -411,7 +411,7 @@ pub(crate) fn run(id: &str) { let model = repo_model::Model::load(&root.join("model").into_std_path_buf()) .expect("the model loads"); let table = spec_table(); - assert_eq!(table.len(), 392, "§31 has 392 rows"); + assert_eq!(table.len(), 396, "§31 has 396 rows"); assert_eq!(model.ids.id.len(), table.len(), "register row count"); for ((spec_id, spec_suite, spec_statement), row) in table.iter().zip(model.ids.id.iter()) diff --git a/crates/conformance/src/support.rs b/crates/conformance/src/support.rs index 20da8b677..03377c75d 100644 --- a/crates/conformance/src/support.rs +++ b/crates/conformance/src/support.rs @@ -379,6 +379,30 @@ impl P { Self { temp, root } } + /// A fresh copy of the committed source-package workspace + /// (`tests/packages/workspace`, SPEC.md §10.5): `root` is the member + /// project `member` (`app`, `lib`, or `base`), and the workspace itself is + /// [`Self::workspace_dir`]. The members carry no lock and no build output. + #[must_use] + pub fn package_workspace(member: &str) -> Self { + let temp = tempfile::Builder::new() + .prefix("lexlean-packages-case-") + .tempdir() + .expect("tempdir"); + let source = repo_root().join("tests/packages/workspace"); + assert!(source.is_dir(), "the package workspace fixture is required"); + copy_tree(source.as_std_path(), temp.path(), &[]); + let root = Utf8PathBuf::from_path_buf(temp.path().join(member)).expect("utf8 tempdir"); + assert!(root.is_dir(), "`{member}` is a member of the fixture"); + Self { temp, root } + } + + /// The directory holding the project copies of [`Self::package_workspace`]. + #[must_use] + pub fn workspace_dir(&self) -> Utf8PathBuf { + Utf8PathBuf::from_path_buf(self.temp.path().to_path_buf()).expect("utf8 tempdir") + } + /// A fresh copy of the preservation library's own project (SPEC.md /// §17.17), without build output or a lock. #[must_use] diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index 0d035589f..cf9060d8c 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1964,3 +1964,23 @@ fn conformance_rt_03() { fn conformance_rt_04() { repo_conformance::cases::run("RT-04"); } + +#[test] +fn conformance_pk_01() { + repo_conformance::cases::run("PK-01"); +} + +#[test] +fn conformance_pk_02() { + repo_conformance::cases::run("PK-02"); +} + +#[test] +fn conformance_pk_03() { + repo_conformance::cases::run("PK-03"); +} + +#[test] +fn conformance_pk_04() { + repo_conformance::cases::run("PK-04"); +} diff --git a/crates/lexlean/src/api.rs b/crates/lexlean/src/api.rs index 1be7bf840..2fac21e5c 100644 --- a/crates/lexlean/src/api.rs +++ b/crates/lexlean/src/api.rs @@ -416,6 +416,7 @@ pub fn render_build( module: name.clone(), lean_module: lean_module.clone(), source_path: checked_module.document.source_path.clone(), + origin: checked_module.document.origin.clone(), }); modules.push(RenderedModule { module: name.clone(), @@ -809,6 +810,17 @@ impl Engine { let existing = crate::lock::read_lock_bytes(&self.project) .map_err(LexLeanError::from_diagnostic)?; if existing != bytes { + // §10.5: a source package that is not the one the lock pins + // is named with both digests, not called a stale lock. + if let Ok(committed) = + crate::lock::parse_lock(&self.project.config.lockfile, &existing) + { + crate::source_package::check_pins( + &committed.source_packages, + &lock.source_packages, + ) + .map_err(LexLeanError::from_diagnostics)?; + } return Err(LexLeanError::from_diagnostic(Diagnostic::new( code!("LLC0102"), format!( @@ -1090,6 +1102,10 @@ impl Engine { let (checked, _lock) = self.checked(&request.selection)?; let mut units = BTreeMap::new(); for (name, module) in &checked.modules { + // A module of a source package is the package's file (§10.5). + if module.document.origin.is_some() { + continue; + } let canonical = crate::fmt::canonical_source(module, &checked.closure) .map_err(LexLeanError::from_diagnostic)?; let raw = raw_bytes(&module.document.source_path)?; @@ -1133,7 +1149,16 @@ impl Engine { .map(|path| path.join("project")) .map_err(LexLeanError::from_diagnostic)?; self.scratch_project_copy(&scratch)?; - let scratch_engine = Self::load(&scratch.join(&self.project.config_name))?; + let scratch_engine = match (&self.project.workspace, &self.project.workspace_member) { + (Some(workspace), Some(member)) => Self { + project: Project::load_as_member( + &scratch.join(&self.project.config_name), + workspace, + member, + )?, + }, + _ => Self::load(&scratch.join(&self.project.config_name))?, + }; for relative in scratch_engine .project .all_modules() @@ -1152,6 +1177,9 @@ impl Engine { let mut units = BTreeMap::new(); let mut rewrites: Vec<(String, String)> = Vec::new(); for (name, module) in &before.modules { + if module.document.origin.is_some() { + continue; + } let canonical = crate::fmt::canonical_source(module, &before.closure) .map_err(LexLeanError::from_diagnostic)?; let raw = raw_bytes(&module.document.source_path)?; @@ -1178,6 +1206,9 @@ impl Engine { } // The canonical text must itself be a fixed point. for (name, module) in &after.modules { + if module.document.origin.is_some() { + continue; + } let again = crate::fmt::canonical_source(module, &after.closure) .map_err(LexLeanError::from_diagnostic)?; if again != module.normalized { diff --git a/crates/lexlean/src/artifact/manifest.rs b/crates/lexlean/src/artifact/manifest.rs index 678c7a037..bcf0f4ccf 100644 --- a/crates/lexlean/src/artifact/manifest.rs +++ b/crates/lexlean/src/artifact/manifest.rs @@ -39,6 +39,9 @@ pub struct ModuleRow { pub lean_module: String, /// The project-relative source path. pub source_path: String, + /// The source package the module belongs to (SPEC.md §10.5), absent for a + /// module of the project itself. + pub origin: Option, } /// The build manifest (§21.6). It never contains its own hash. @@ -111,11 +114,15 @@ impl BuildManifest { self.modules .iter() .map(|row| { - Json::object(vec![ + let mut fields = vec![ ("module", Json::Str(row.module.clone())), ("lean_module", Json::Str(row.lean_module.clone())), ("source_path", Json::Str(row.source_path.clone())), - ]) + ]; + if let Some(origin) = &row.origin { + fields.push(("origin", Json::Str(origin.clone()))); + } + Json::object(fields) }) .collect(), ), diff --git a/crates/lexlean/src/artifact/snapshot.rs b/crates/lexlean/src/artifact/snapshot.rs index e01f0a631..aecf0d64d 100644 --- a/crates/lexlean/src/artifact/snapshot.rs +++ b/crates/lexlean/src/artifact/snapshot.rs @@ -30,6 +30,9 @@ pub struct SemanticSnapshot { pub struct SnapshotModule { name: String, lean_module: String, + /// The source package the module belongs to (SPEC.md §10.5). + #[serde(default, skip_serializing_if = "Option::is_none")] + origin: Option, imports: Vec, glossary: Vec, visible_packages: Vec, @@ -346,6 +349,7 @@ impl SemanticSnapshot { modules.push(SnapshotModule { name: name.clone(), lean_module: module.document.lean_module.clone(), + origin: module.document.origin.clone(), imports: module.document.imports.clone(), glossary: module.document.glossary.clone(), visible_packages: module.visible.iter().cloned().collect(), diff --git a/crates/lexlean/src/backend/lean.rs b/crates/lexlean/src/backend/lean.rs index 10ff1006a..161ad3838 100644 --- a/crates/lexlean/src/backend/lean.rs +++ b/crates/lexlean/src/backend/lean.rs @@ -2028,17 +2028,13 @@ pub fn document_externals( /// of every reached external constant plus the full generated names of /// document imports. #[must_use] -pub fn module_imports( - document: &DocumentModule, - closure: &Closure, - module_prefix: &str, -) -> Vec { +pub fn module_imports(document: &DocumentModule, closure: &Closure) -> Vec { let mut imports: BTreeSet = BTreeSet::new(); for external in document_externals(document, closure).values() { imports.insert(external.lean_module.clone()); } for import in &document.imports { - imports.insert(format!("{module_prefix}.{import}")); + imports.insert(document.lean_import(import)); } imports.into_iter().collect() } @@ -2108,7 +2104,7 @@ pub fn render_module( }; sink.kw("module"); sink.ws("\n"); - for import in module_imports(document, closure, module_prefix) { + for import in module_imports(document, closure) { // Under the Lean 4.32.1 module system a plain `import` is // private: constants of the imported module may not appear in // the signatures of this module's `public` declarations. Every diff --git a/crates/lexlean/src/backend/semantic.rs b/crates/lexlean/src/backend/semantic.rs index f1815f609..fa719445f 100644 --- a/crates/lexlean/src/backend/semantic.rs +++ b/crates/lexlean/src/backend/semantic.rs @@ -21,6 +21,9 @@ mod reasoning; struct Render<'a> { prefix: &'a str, + /// The Lean module each imported module's key names; a module not in it + /// lies under `prefix` (§10.5). + lean_imports: &'a std::collections::BTreeMap, /// §17.12: in a well-founded definition, each `if` (by node address) /// lowers to a dependent match binding its numbered hypothesis. hypotheses: std::collections::BTreeMap, @@ -344,7 +347,14 @@ impl Render<'_> { .split_once('.') .is_some_and(|(owner, _)| BUILTIN_CONSTRUCTOR_OWNERS.contains(&owner)); match (&member.module, self.qualify) { - (Some(module), _) => identifier(&format!("{}.{}.{}", self.prefix, module, member.name)), + (Some(module), _) => identifier(&format!( + "{}.{}", + self.lean_imports + .get(module) + .cloned() + .unwrap_or_else(|| format!("{}.{module}", self.prefix)), + member.name + )), (None, Some(own)) if !builtin => identifier(&format!("{own}.{}", member.name)), (None, _) => identifier(&member.name), } @@ -553,6 +563,7 @@ impl Render<'_> { fn cross_check(&self, check: &CrossCheck, module: &str) -> String { let qualified = Render { prefix: self.prefix, + lean_imports: self.lean_imports, hypotheses: std::collections::BTreeMap::new(), document: false, qualify: Some(module), @@ -1341,6 +1352,7 @@ fn well_founded_definition( })?; let render = Render { prefix: base.prefix, + lean_imports: base.lean_imports, hypotheses: plan .addresses .iter() @@ -1745,6 +1757,7 @@ pub fn render_lean( let document = &checked.document; let base_render = Render { prefix: module_prefix, + lean_imports: &document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: false, qualify: None, @@ -1754,6 +1767,7 @@ pub fn render_lean( // reference it makes is written qualified (§17.12, models). let model_render = Render { prefix: module_prefix, + lean_imports: &document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: false, qualify: Some(&document.lean_module), @@ -1793,7 +1807,7 @@ pub fn render_lean( for import in &document.imports { text.push_str(&format!( "public import {}\n", - identifier(&format!("{module_prefix}.{import}")) + identifier(&document.lean_import(import)) )); } // Large closed byte constants incur Lean compiler work beyond its small @@ -2731,6 +2745,7 @@ pub fn render_latex( ) -> Result { let render = Render { prefix: module_prefix, + lean_imports: &checked.document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: true, qualify: None, diff --git a/crates/lexlean/src/cli.rs b/crates/lexlean/src/cli.rs index a1924a3f2..5f8f9f9f3 100644 --- a/crates/lexlean/src/cli.rs +++ b/crates/lexlean/src/cli.rs @@ -786,6 +786,7 @@ fn init_project( package: "lexlean.std.nat".to_owned(), }], artifact_sources: Vec::new(), + source_packages: Vec::new(), limits: INIT_LIMITS, pdf: None, }; diff --git a/crates/lexlean/src/config.rs b/crates/lexlean/src/config.rs index 6bca577f1..2f9cc39e6 100644 --- a/crates/lexlean/src/config.rs +++ b/crates/lexlean/src/config.rs @@ -179,6 +179,19 @@ pub struct ArtifactSource { pub path: String, } +/// Language 1.2: one source package a project imports modules from (§10.5): a +/// member project of the workspace, pinned in the lock by the digest of its +/// manifest and source files. `kind` is `path` and nothing else. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SourcePackage { + /// The package identifier, unique in the project. + pub package: String, + /// The version, for readers: the pin is the digest. + pub version: String, + /// The workspace-relative member directory. + pub path: String, +} + /// The validated project configuration. #[derive(Debug, Clone, PartialEq, Eq)] pub struct ProjectConfig { @@ -202,6 +215,8 @@ pub struct ProjectConfig { pub lexicon_sources: Vec, /// Language 1.2: model artifact sources, sorted by digest. pub artifact_sources: Vec, + /// Language 1.2: source packages, sorted by package. + pub source_packages: Vec, /// The explicit resource policy. pub limits: Limits, /// The optional PDF provider. @@ -225,6 +240,8 @@ struct RawProject { lexicon_sources: Vec, #[serde(default, rename = "artifact_source")] artifact_sources: Option>, + #[serde(default, rename = "source_package")] + source_packages: Option>, limits: Limits, pdf: Option, } @@ -247,6 +264,15 @@ struct RawArtifactSource { path: String, } +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawSourcePackage { + package: String, + version: String, + kind: String, + path: String, +} + #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RawPdf { @@ -364,6 +390,19 @@ pub fn is_project_name(text: &str) -> bool { .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || *b == b'-') } +/// A source package version (§10.5): a reader's string of ASCII letters, +/// digits, `.`, `+`, and `-`, beginning with a letter or digit, of at most 64 +/// characters. It is pinned in the lock, never interpreted. +#[must_use] +pub fn is_package_version(text: &str) -> bool { + let bytes = text.as_bytes(); + (1..=64).contains(&bytes.len()) + && bytes[0].is_ascii_alphanumeric() + && bytes + .iter() + .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'.' | b'+' | b'-')) +} + /// One `[A-Z][A-Za-z0-9_]*` Lean-name segment (§10.1). #[must_use] pub fn is_module_segment(text: &str) -> bool { @@ -793,6 +832,76 @@ pub fn parse_project(path: &str, bytes: &[u8]) -> Result None, @@ -921,6 +1030,7 @@ pub fn parse_project(path: &str, bytes: &[u8]) -> Result, /// Used glossary packages, `package@version`, sorted. pub glossary: Vec, - /// Explicit module imports, sorted. + /// Explicit module imports, by the names the linked project gives the + /// modules, sorted. pub imports: Vec, + /// The Lean module each import names. A module of the project imports + /// another under the project's prefix; a module of a source package, or a + /// module that imports one, names it by its own Lean name. + pub import_lean: BTreeMap, /// The title phrase. pub title: Phrase, /// Top-level blocks in source order. @@ -115,6 +123,27 @@ pub struct DocumentModule { } impl DocumentModule { + /// The Lean module an import of this module names (§18.3). + #[must_use] + pub fn lean_import(&self, import: &str) -> String { + self.import_lean + .get(import) + .cloned() + .unwrap_or_else(|| self.default_lean_import(import)) + } + + /// The Lean module an import names when it lies under the same module + /// prefix as this module: its key beneath the prefix this module's Lean + /// name carries. A module of a source package carries its prefix in its + /// key, so it has no such prefix. + fn default_lean_import(&self, import: &str) -> String { + let stem = self + .lean_module + .strip_suffix(self.name.as_str()) + .unwrap_or_default(); + format!("{stem}{import}") + } + /// Every declaration in source order, with its inherited-parameter /// context flattened by the linker. #[must_use] @@ -199,6 +228,20 @@ impl DocumentModule { ), ), ]; + // Written only for a module of a source package or one that imports + // one, so every other project keeps its linked bytes (§10.5). + if let Some(origin) = &self.origin { + fields.push(("origin", Json::Str(origin.clone()))); + } + let foreign: Vec<(&str, Json)> = self + .import_lean + .iter() + .filter(|(import, lean)| **lean != self.default_lean_import(import)) + .map(|(import, lean)| (import.as_str(), Json::Str(lean.clone()))) + .collect(); + if !foreign.is_empty() { + fields.push(("import_lean", Json::object(foreign))); + } if let Some(core) = &self.core { fields.push(( "core", diff --git a/crates/lexlean/src/lib.rs b/crates/lexlean/src/lib.rs index 0e4256353..a071685c0 100644 --- a/crates/lexlean/src/lib.rs +++ b/crates/lexlean/src/lib.rs @@ -57,6 +57,8 @@ pub mod project; #[doc(hidden)] pub mod source; #[doc(hidden)] +pub mod source_package; +#[doc(hidden)] pub mod surface; #[doc(hidden)] pub mod verify; diff --git a/crates/lexlean/src/link.rs b/crates/lexlean/src/link.rs index 7931039c8..57c9b4725 100644 --- a/crates/lexlean/src/link.rs +++ b/crates/lexlean/src/link.rs @@ -306,6 +306,29 @@ struct ModuleLoad { normalized: String, atoms: Vec, ast: ModuleAst, + /// The source package the module belongs to, absent for the project's own + /// (§10.5). + package: Option, + /// The module's name inside its own project: its header names it, and a + /// package's source writes its references to its siblings by it. + relative_name: String, + /// Each import as written, with the key of the module it names in the + /// importing project, in source order. + import_keys: Vec<(String, String)>, + /// The module prefix the module's Lean name lies under: its project's, or + /// its package's (§10.5). + prefix: String, +} + +/// Where a module of the linked project is read from (§10.5). +#[derive(Clone)] +struct ModuleSource { + /// The source package, absent for the project's own modules. + package: Option, + /// The module's name inside its own project. + relative_name: String, + /// The project-relative path, or the member-relative path of a package. + path: String, } /// Run the complete check pipeline for a selection on a dedicated thread @@ -452,29 +475,68 @@ fn check_project_inline( return Err(error); } - // Load the selection, then the transitive import closure (§15.1). - let all_modules = project.all_modules().map_err(err)?; + // Load the selection, then the transitive import closure (§15.1). A + // module of a source package is read from the bytes the pin covers, so + // nothing but the verified tree is ever linked (§10.5). + let source_packages = crate::source_package::load_locked(project, lock).map_err(err)?; + let own_modules = project.all_modules().map_err(err)?; let selected = project.resolve_selection(selection).map_err(err)?; let mut loaded: BTreeMap = BTreeMap::new(); - let mut worklist: Vec<(String, String)> = selected + let mut worklist: Vec<(String, ModuleSource)> = selected .iter() - .map(|(module, path)| (module.clone(), path.clone())) + .map(|(module, path)| { + ( + module.clone(), + ModuleSource { + package: None, + relative_name: module.clone(), + path: path.clone(), + }, + ) + }) .collect(); - while let Some((module_name, relative)) = worklist.pop() { - if loaded.contains_key(&module_name) { + while let Some((module_name, source)) = worklist.pop() { + if let Some(existing) = loaded.get(&module_name) { + if existing.package != source.package { + return Err(err(vec![Diagnostic::new( + code!("LLC0107"), + format!( + "module `{module_name}` is provided by both the project and a source package" + ), + )])); + } continue; } - let absolute = project - .confined_file_or_missing(&relative, || { - Diagnostic::new(code!("LLC0002"), format!("`{relative}` does not exist")) - }) - .map_err(|diagnostic| err(vec![diagnostic]))?; - let bytes = std::fs::read(absolute.as_std_path()).map_err(|io_error| { - err(vec![Diagnostic::new( - code!("LLS8001"), - format!("{relative}: {io_error}"), - )]) - })?; + let scope_package = source + .package + .as_ref() + .and_then(|id| source_packages.packages.get(id)); + let (relative, bytes) = match scope_package { + None => { + let relative = source.path.clone(); + let absolute = project + .confined_file_or_missing(&relative, || { + Diagnostic::new(code!("LLC0002"), format!("`{relative}` does not exist")) + }) + .map_err(|diagnostic| err(vec![diagnostic]))?; + let bytes = std::fs::read(absolute.as_std_path()).map_err(|io_error| { + err(vec![Diagnostic::new( + code!("LLS8001"), + format!("{relative}: {io_error}"), + )]) + })?; + (relative, bytes) + } + Some(package) => { + let bytes = package.files.get(&source.path).cloned().ok_or_else(|| { + err(vec![Diagnostic::new( + code!("LLC0002"), + format!("`{}` does not exist", package.display_path(&source.path)), + )]) + })?; + (package.display_path(&source.path), bytes) + } + }; if bytes.len() as u64 > limits.max_file_bytes { return Err(err(vec![Diagnostic::new( code!("LLS8002"), @@ -500,31 +562,33 @@ fn check_project_inline( &closure.bootstrap.structural.forbidden_controls, ) .map_err(|diagnostic| err(vec![diagnostic]))?; - let ast = structural::parse_module(&relative, &atoms, &module_name, limits.max_scope_depth) - .map_err(|diagnostic| err(vec![diagnostic]))?; + let ast = structural::parse_module( + &relative, + &atoms, + &source.relative_name, + limits.max_scope_depth, + ) + .map_err(|diagnostic| err(vec![diagnostic]))?; + let mut import_keys: Vec<(String, String)> = Vec::new(); for import in &ast.imports { - let import_name = import.text.clone(); - if import_name == module_name { + let (import_key, import_source) = resolve_import( + &source_packages, + &own_modules, + scope_package, + &module_name, + &import.text, + ) + .map_err(|diagnostic| err(vec![diagnostic]))?; + if import_key == module_name { return Err(err(vec![Diagnostic::new( code!("LLR3003"), format!("module `{module_name}` imports itself"), )])); } - if !loaded.contains_key(&import_name) { - match all_modules.get(&import_name) { - Some(import_path) => { - worklist.push((import_name, import_path.clone())); - } - None => { - return Err(err(vec![Diagnostic::new( - code!("LLR3005"), - format!( - "`{module_name}` imports `{import_name}`, which is not a project module" - ), - )])); - } - } + if !loaded.contains_key(&import_key) { + worklist.push((import_key.clone(), import_source)); } + import_keys.push((import.text.clone(), import_key)); } loaded.insert( module_name, @@ -533,6 +597,13 @@ fn check_project_inline( normalized, atoms, ast, + prefix: scope_package.map_or_else( + || project.config.module_prefix.clone(), + |package| package.prefix.clone(), + ), + package: source.package, + relative_name: source.relative_name, + import_keys, }, ); } @@ -564,7 +635,8 @@ fn check_project_inline( // as data, so it captures none, and the proof library's modules are // named for what they state (`Fixed`, `Keys`). if project.config.language == crate::LANGUAGE_1_2 && load.ast.core.is_none() { - if let Some(segment) = crate::ir::semantic::reserved_module_segment(module_name) { + if let Some(segment) = crate::ir::semantic::reserved_module_segment(&load.relative_name) + { return Err(err(vec![Diagnostic::new( code!("LLT4001"), format!( @@ -622,28 +694,49 @@ fn check_project_inline( // Module imports: sorted, unique, direct-availability (§15.1, §17.7). let mut imports: Vec = Vec::new(); - for import in &load.ast.imports { - if imports.contains(&import.text) { + let mut written_imports: Vec = Vec::new(); + for (import, (_, key)) in load.ast.imports.iter().zip(&load.import_keys) { + if written_imports.contains(&import.text) { return Err(err(vec![Diagnostic::new( code!("LLP2003"), format!("duplicate \\importmodule{{{}}}", import.text), ) .with_span(span_of_range(&load.path, &load.atoms, import.range))])); } - imports.push(import.text.clone()); + written_imports.push(import.text.clone()); + imports.push(key.clone()); } imports.sort(); + // Inside a package a module writes its references to a sibling by the + // sibling's own name; the linked project names the sibling by its key. + // The declarations a module sees carry the name the module writes. + let renamed: BTreeMap = load + .import_keys + .iter() + .filter(|(written, key)| written != key) + .map(|(written, key)| (key.clone(), written.clone())) + .collect(); // The declarations visible to this module: its direct imports' // declarations, in availability order; its own grow as blocks link. let mut module_decls = DeclTable::default(); for row in &decls.rows { if imports.contains(&row.module) { - module_decls.rows.push(row.clone()); + let mut visible_row = row.clone(); + if let Some(written) = renamed.get(&row.module) { + visible_row.module = written.clone(); + } + module_decls.rows.push(visible_row); } } - let lean_module = format!("{}.{}", project.config.module_prefix, module_name); + // A package module is named by its Lean name throughout the linked + // project; the project's own are named under the project's prefix. + let lean_module = if load.package.is_some() { + module_name.clone() + } else { + format!("{}.{}", project.config.module_prefix, module_name) + }; let mut rows: Vec = load.ast.structural_rows.clone(); let mut scopes = ScopeStack::default(); scopes.push_frame(); @@ -661,7 +754,7 @@ fn check_project_inline( visible: &visible, decls: &module_decls, module: module_name, - module_prefix: &project.config.module_prefix, + module_prefix: &load.prefix, }; elab_phrase( &shared, @@ -678,7 +771,6 @@ fn check_project_inline( let mut blocks: Vec = Vec::new(); for block in &load.ast.blocks { let linked = link_block( - project, &closure, &visible, &mut module_decls, @@ -811,11 +903,36 @@ fn check_project_inline( } else { std::borrow::Cow::Borrowed(ast.data.text.as_str()) }; + // A package's source writes a sibling module by its own name; the + // linked project names it by its key, so the references are read + // under the key and every later phase finds the module (§10.5). + let data: std::borrow::Cow<'_, str> = if renamed.is_empty() { + data + } else { + let to_key: BTreeMap = renamed + .iter() + .map(|(key, written)| (written.clone(), key.clone())) + .collect(); + let mut json = crate::artifact::canonical_json::Json::parse(data.as_bytes()) + .map_err(|reason| { + err(vec![Diagnostic::new( + code!("LLP2001"), + format!("phase link: semantic data: {reason}"), + ) + .with_span(span_of_range( + &load.path, + &load.atoms, + ast.data.range, + ))]) + })?; + rename_member_modules(&mut json, &to_key); + std::borrow::Cow::Owned(json.to_canonical_string()) + }; Some( SemanticModule::parse( &data, &project.config.language, - &project.config.module_prefix, + &load.prefix, &imports, &imported_semantic, &artifacts, @@ -899,7 +1016,12 @@ fn check_project_inline( // §17.13: every production root is analysed over the linked // closure of this module and its imports before any backend runs. let production = match &semantic { - Some(semantic) if project.config.language == crate::LANGUAGE_1_2 => { + // A package's own production roots are roots of its project, built + // when it is built; imported, its definitions are ordinary ones + // (§10.5), so no module of a package is analysed here. + Some(semantic) + if project.config.language == crate::LANGUAGE_1_2 && load.package.is_none() => + { let mut linked: BTreeMap> = modules .iter() @@ -978,12 +1100,22 @@ fn check_project_inline( } report_bytes = report_bytes.saturating_add(production.as_ref().map_or(0, |report| report.bytes)); + let import_lean: BTreeMap = imports + .iter() + .filter_map(|key| { + modules + .get(key) + .map(|module| (key.clone(), module.document.lean_module.clone())) + }) + .collect(); let document = DocumentModule { name: module_name.clone(), lean_module, source_path: load.path.clone(), source_sha256: Sha256Digest::of(load.normalized.as_bytes()), + origin: load.package.clone(), glossary, + import_lean, imports, title, blocks, @@ -1083,6 +1215,122 @@ fn check_project_inline( }) } +/// Rename the modules that the member references of `json` (an object of +/// exactly a string `module` and a string `name`) write, by `map`. +fn rename_member_modules( + json: &mut crate::artifact::canonical_json::Json, + map: &BTreeMap, +) { + use crate::artifact::canonical_json::Json; + match json { + Json::Arr(items) => { + for item in items { + rename_member_modules(item, map); + } + } + Json::Obj(fields) => { + let is_member = fields.len() == 2 + && matches!(fields.get("module"), Some(Json::Str(_))) + && matches!(fields.get("name"), Some(Json::Str(_))); + if is_member { + if let Some(Json::Str(module)) = fields.get_mut("module") { + if let Some(key) = map.get(module.as_str()) { + module.clone_from(key); + } + } + } + for value in fields.values_mut() { + rename_member_modules(value, map); + } + } + Json::Bool(_) | Json::Int(_) | Json::Str(_) => {} + } +} + +/// Resolve one import of a module to the key of the module it names in the +/// importing project (§10.5): a module of the module's own project, or a +/// module of a package that project declares, which is written with the +/// package's module prefix. Anything else is not a dependency of the module. +fn resolve_import( + packages: &crate::source_package::SourcePackages, + own: &BTreeMap, + scope: Option<&crate::source_package::ResolvedSourcePackage>, + importer: &str, + text: &str, +) -> Result<(String, ModuleSource), Diagnostic> { + let local = match scope { + None => own.get(text).map(|path| { + ( + text.to_owned(), + ModuleSource { + package: None, + relative_name: text.to_owned(), + path: path.clone(), + }, + ) + }), + Some(package) => package.modules.get(text).map(|path| { + ( + package.key(text), + ModuleSource { + package: Some(package.id.clone()), + relative_name: text.to_owned(), + path: path.clone(), + }, + ) + }), + }; + let declared: &[String] = match scope { + None => &packages.declared, + Some(package) => &package.dependencies, + }; + let foreign = declared.iter().find_map(|id| { + let package = packages.packages.get(id)?; + let relative = text + .strip_prefix(package.prefix.as_str())? + .strip_prefix('.')?; + let path = package.modules.get(relative)?; + Some(( + text.to_owned(), + ModuleSource { + package: Some(package.id.clone()), + relative_name: relative.to_owned(), + path: path.clone(), + }, + )) + }); + match (local, foreign) { + (Some(_), Some(_)) => Err(Diagnostic::new( + code!("LLC0107"), + format!( + "`{importer}` imports `{text}`, which both its own project and a source package provide" + ), + )), + (Some(hit), None) | (None, Some(hit)) => Ok(hit), + (None, None) => { + if let Some((owner, _)) = packages.owner_of_key(text) { + if scope.is_none_or(|package| package.id != owner.id) { + return Err(Diagnostic::new( + code!("LLR3009"), + format!( + "`{importer}` imports `{text}`, a module of source package `{}`, which {} does not declare", + owner.id, + scope.map_or_else( + || "the project".to_owned(), + |package| format!("source package `{}`", package.id) + ) + ), + )); + } + } + Err(Diagnostic::new( + code!("LLR3005"), + format!("`{importer}` imports `{text}`, which is not a project module"), + )) + } + } +} + fn topo_order(loaded: &BTreeMap) -> Result, String> { let mut order = Vec::new(); let mut state: BTreeMap<&str, u8> = BTreeMap::new(); @@ -1099,10 +1347,10 @@ fn topo_order(loaded: &BTreeMap) -> Result, Stri } state.insert(name, 1); if let Some(load) = loaded.get(name) { - for import in &load.ast.imports { - if loaded.contains_key(&import.text) { + for (_, import_key) in &load.import_keys { + if loaded.contains_key(import_key) { let key = loaded - .get_key_value(&import.text) + .get_key_value(import_key) .map(|(k, _)| k.as_str()) .unwrap_or(name); visit(key, loaded, state, order)?; @@ -1405,7 +1653,6 @@ fn elab_binder_list( #[allow(clippy::too_many_arguments, clippy::too_many_lines)] fn link_block( - project: &Project, closure: &Closure, visible: &BTreeSet, module_decls: &mut DeclTable, @@ -1445,7 +1692,7 @@ fn link_block( visible, decls: module_decls, module: module_name, - module_prefix: &project.config.module_prefix, + module_prefix: &load.prefix, }; let (heading_phrase, heading_rows) = elab_phrase(&shared, scopes, alloc, budget, *heading)?; @@ -1466,7 +1713,6 @@ fn link_block( let mut inner = Vec::new(); for child in blocks { match link_block( - project, closure, visible, module_decls, @@ -1501,7 +1747,6 @@ fn link_block( } BlockAst::Declaration(decl) => { let declaration = link_declaration( - project, closure, visible, module_decls, @@ -1526,7 +1771,6 @@ fn link_block( #[allow(clippy::too_many_arguments, clippy::too_many_lines)] fn link_declaration( - project: &Project, closure: &Closure, visible: &BTreeSet, module_decls: &mut DeclTable, @@ -1585,7 +1829,7 @@ fn link_declaration( visible, decls: module_decls, module: module_name, - module_prefix: &project.config.module_prefix, + module_prefix: &load.prefix, }; let origin = DeclOrigin { whole: bytes_of(&load.atoms, (decl.begin, decl.end)), diff --git a/crates/lexlean/src/lock.rs b/crates/lexlean/src/lock.rs index 579fb53dc..872a28b08 100644 --- a/crates/lexlean/src/lock.rs +++ b/crates/lexlean/src/lock.rs @@ -36,6 +36,28 @@ pub struct LockPackage { pub imports: Vec, } +/// One locked source package row (§10.5, §11.1): the pin of a package of the +/// workspace by the digest of its manifest and source files. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LockSourcePackage { + /// The package identifier. + pub id: String, + /// The declared version, for readers. + pub version: String, + /// `path`. + pub kind: String, + /// The workspace-relative member directory. + pub source: String, + /// The package's module prefix. + pub module_prefix: String, + /// The tree digest over the manifest and the source files. + pub tree_sha256: Sha256Digest, + /// SHA-256 of the manifest. + pub manifest_sha256: Sha256Digest, + /// Sorted unique `package@version` of the packages it declares. + pub imports: Vec, +} + /// A locked PDF provider record (§11.1): it mirrors the configured /// provider (program, argument vectors, output pattern, hashes) and records /// the hash of every declared resource. @@ -70,6 +92,9 @@ pub struct Lock { pub workspace_files: Vec<(String, Sha256Digest)>, /// Package rows sorted by `(id, version)`. pub packages: Vec, + /// Language 1.2: source package rows sorted by identifier, the + /// transitive closure of the project's source packages. + pub source_packages: Vec, /// The optional PDF record. pub pdf: Option, } @@ -130,6 +155,30 @@ impl Lock { let imports: Vec = package.imports.iter().map(|i| toml_string(i)).collect(); out.push_str(&format!("imports = [{}]\n", imports.join(", "))); } + // Written only when the project declares source packages, so every + // other lock keeps its bytes. + let mut source_packages = self.source_packages.clone(); + source_packages.sort_by(|a, b| a.id.cmp(&b.id)); + for package in &source_packages { + out.push_str("\n[[source_package]]\n"); + out.push_str(&format!("id = {}\n", toml_string(&package.id))); + out.push_str(&format!("version = {}\n", toml_string(&package.version))); + out.push_str(&format!("kind = {}\n", toml_string(&package.kind))); + out.push_str(&format!("source = {}\n", toml_string(&package.source))); + out.push_str(&format!( + "module_prefix = {}\n", + toml_string(&package.module_prefix) + )); + out.push_str(&format!( + "tree_sha256 = {}\n", + toml_string(&package.tree_sha256.to_hex()) + )); + out.push_str(&format!( + "manifest_sha256 = {}\n", + toml_string(&package.manifest_sha256.to_hex()) + )); + out.push_str(&format!("imports = {}\n", toml_array(&package.imports))); + } if let Some(pdf) = &self.pdf { out.push_str("\n[pdf]\n"); out.push_str(&format!("program = {}\n", toml_string(&pdf.program))); @@ -174,6 +223,8 @@ struct RawLock { workspace_files: Vec, #[serde(rename = "package", default)] packages: Vec, + #[serde(rename = "source_package", default)] + source_packages: Vec, pdf: Option, } @@ -197,6 +248,19 @@ struct RawLockPackage { imports: Vec, } +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawLockSourcePackage { + id: String, + version: String, + kind: String, + source: String, + module_prefix: String, + tree_sha256: String, + manifest_sha256: String, + imports: Vec, +} + #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RawLockPdf { @@ -325,6 +389,66 @@ pub fn parse_lock(path: &str, bytes: &[u8]) -> Result> { ))); } } + // §10.5: the rows of the source packages, language 1.2 only, sorted and + // unique by identifier, each `package@version` import well formed. + if !raw.source_packages.is_empty() && raw.language != crate::LANGUAGE_1_2 { + diagnostics.push(lock_error(format!( + "{path}: source_package rows are a language-1.2 field" + ))); + } + if !raw + .source_packages + .windows(2) + .all(|pair| pair[0].id < pair[1].id) + { + diagnostics.push(lock_error(format!( + "{path}: source_package rows must be unique and sorted by id" + ))); + } + let mut source_packages = Vec::new(); + for row in &raw.source_packages { + if row.kind != "path" { + diagnostics.push(lock_error(format!( + "{path}: source package `{}` has kind `{}`, not `path`", + row.id, row.kind + ))); + } + for import in &row.imports { + let well_formed = import.split_once('@').is_some_and(|(id, version)| { + crate::config::is_project_name(id) && crate::config::is_package_version(version) + }); + if !well_formed { + diagnostics.push(lock_error(format!( + "{path}: source package `{}` has invalid import `{import}`", + row.id + ))); + } + } + if !row.imports.windows(2).all(|pair| pair[0] < pair[1]) { + diagnostics.push(lock_error(format!( + "{path}: source package `{}` imports are not sorted and unique", + row.id + ))); + } + source_packages.push(LockSourcePackage { + id: row.id.clone(), + version: row.version.clone(), + kind: row.kind.clone(), + source: row.source.clone(), + module_prefix: row.module_prefix.clone(), + tree_sha256: hex( + "source_package.tree_sha256", + &row.tree_sha256, + &mut diagnostics, + ), + manifest_sha256: hex( + "source_package.manifest_sha256", + &row.manifest_sha256, + &mut diagnostics, + ), + imports: row.imports.clone(), + }); + } let pdf = raw.pdf.as_ref().map(|raw_pdf| LockPdf { program: raw_pdf.program.clone(), version_argv: raw_pdf.version_argv.clone(), @@ -357,6 +481,7 @@ pub fn parse_lock(path: &str, bytes: &[u8]) -> Result> { project_config_sha256, workspace_files, packages, + source_packages, pdf, }; if diagnostics.is_empty() { @@ -1122,6 +1247,7 @@ pub fn compute_lock( allow_network: bool, ) -> Result<(Lock, Vec), Vec> { let resolved = resolve_packages(project, allow_network)?; + let source_packages = crate::source_package::resolve(project)?; // The closure must include every transitive import exactly once (§11.3); // imports of loaded packages must all be loaded. @@ -1187,6 +1313,7 @@ pub fn compute_lock( project_config_sha256: project.config.config_sha256(), workspace_files, packages: resolved.rows, + source_packages: source_packages.rows(), pdf, }, resolved.packages, @@ -1219,6 +1346,9 @@ pub fn read_current_lock( let bytes = read_lock_bytes(project).map_err(|d| vec![d])?; let committed = parse_lock(&project.config.lockfile, &bytes)?; let (expected, packages) = compute_lock(project, false)?; + // §10.5: a package that is not the one the lock pins is named with both + // digests before the lock is called stale as a whole. + crate::source_package::check_pins(&committed.source_packages, &expected.source_packages)?; if expected.canonical_bytes() != bytes { let mut mismatch = lock_error(format!( "{} is stale or noncanonical; run `lexlean lock`", diff --git a/crates/lexlean/src/project.rs b/crates/lexlean/src/project.rs index 44b93c9d5..c1fb0eea4 100644 --- a/crates/lexlean/src/project.rs +++ b/crates/lexlean/src/project.rs @@ -9,6 +9,7 @@ use crate::code; use crate::config::{is_module_segment, parse_project, ProjectConfig}; use crate::diagnostic::Diagnostic; use crate::error::LexLeanError; +use crate::source_package::Workspace; /// Rewrite a path the host rendered with its own separator into the /// canonical `/`-separated project-relative spelling. @@ -56,6 +57,13 @@ pub struct Project { /// through [`Project::with_tooling`]; no configuration member, command /// line option, request field, or environment variable can. pub tooling: bool, + /// Language 1.2: the workspace of a project that declares source + /// packages (§10.5). Read when the project loads, and absent for a + /// project that declares none, which reads nothing beside its own root. + pub workspace: Option, + /// The workspace-relative directory of this project among the workspace's + /// members, present exactly when [`Self::workspace`] is. + pub workspace_member: Option, } /// The selection modes (SPEC.md §24.2). @@ -144,6 +152,25 @@ impl Project { /// Load a project from its configuration file path. pub fn load(config_path: &Utf8Path) -> Result { + Self::load_in(config_path, None) + } + + /// Load a project that stands in for a member of `workspace`: a scratch + /// copy of a project made to re-check its formatting, which resolves the + /// packages the original does and has no workspace file of its own. The + /// member is the directory of the project it stands in for. + pub fn load_as_member( + config_path: &Utf8Path, + workspace: &Workspace, + member: &str, + ) -> Result { + Self::load_in(config_path, Some((workspace.clone(), member.to_owned()))) + } + + fn load_in( + config_path: &Utf8Path, + stand_in: Option<(Workspace, String)>, + ) -> Result { // Messages name the configuration as the user gave it when that is // relative, and by file name otherwise (§20.6: no absolute paths). let shown: String = if config_path.is_absolute() { @@ -200,6 +227,8 @@ impl Project { config, config_bytes, tooling: false, + workspace: None, + workspace_member: None, }; // The build root must resolve within the project and no component // of it may be a symlink (§10.1, §25.1); the same holds for the @@ -218,6 +247,21 @@ impl Project { .confined(&workspace, Expect::Creatable) .map_err(LexLeanError::from_diagnostic)?; } + // §10.5: a project that declares source packages belongs to a + // workspace that lists it; a project that declares none reads no + // directory beside its own. + let mut project = project; + if !project.config.source_packages.is_empty() { + if let Some((workspace, member)) = stand_in { + project.workspace = Some(workspace); + project.workspace_member = Some(member); + } else { + let workspace = + Workspace::of_project(&project.root).map_err(LexLeanError::from_diagnostic)?; + project.workspace_member = workspace.member_of(&project.root); + project.workspace = Some(workspace); + } + } Ok(project) } diff --git a/crates/lexlean/src/source_package.rs b/crates/lexlean/src/source_package.rs new file mode 100644 index 000000000..07fe6c8b8 --- /dev/null +++ b/crates/lexlean/src/source_package.rs @@ -0,0 +1,743 @@ +//! Source packages (SPEC.md §10.5): the workspace rule, the resolution of the +//! packages a language-1.2 project declares from member projects of its +//! workspace, and their pins in the lock. +//! +//! A source package is a project. Nothing is fetched: a package is read from a +//! member directory of the workspace, confined to its manifest and its source +//! roots, and hashed; the pin is the digest, and every command recomputes it. + +use std::collections::{BTreeMap, BTreeSet}; + +use camino::{Utf8Path, Utf8PathBuf}; +use serde::Deserialize; + +use crate::artifact::content_id::{tree_digest, Sha256Digest}; +use crate::code; +use crate::config::{ + is_module_segment, is_project_relative, parse_project, LexiconSource, Limits, ProjectConfig, +}; +use crate::diagnostic::Diagnostic; +use crate::lexicon::package::toml_comment_at; +use crate::lock::{Lock, LockSourcePackage}; +use crate::project::Project; + +/// The workspace file name (§10.5), at the root of the workspace. +pub const WORKSPACE_FILE: &str = "lexlean-workspace.toml"; + +/// The workspace schema. +pub const WORKSPACE_SPEC: &str = "lexlean/workspace/1"; + +fn workspace_error(message: impl Into) -> Diagnostic { + Diagnostic::new(code!("LLC0108"), message) +} + +fn security(message: impl Into) -> Diagnostic { + Diagnostic::new(code!("LLS8001"), message) +} + +fn config_error(message: impl Into) -> Diagnostic { + Diagnostic::new(code!("LLC0101"), message) +} + +/// The workspace a project belongs to (§10.5): the directory holding +/// [`WORKSPACE_FILE`] and the member projects it lists. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Workspace { + /// The canonical workspace root. + pub root: Utf8PathBuf, + /// The member project directories, workspace-relative, sorted. + pub members: Vec, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawWorkspace { + spec: String, + members: Vec, +} + +impl Workspace { + /// Read the workspace file of `directory`, when it holds one. A symlinked + /// or unreadable file, or one that is not a `lexlean/workspace/1` + /// document, is refused. + pub fn read(directory: &Utf8Path) -> Result, Diagnostic> { + let file = directory.join(WORKSPACE_FILE); + let metadata = match std::fs::symlink_metadata(file.as_std_path()) { + Ok(metadata) => metadata, + Err(io_error) if io_error.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(io_error) => return Err(security(format!("{WORKSPACE_FILE}: {io_error}"))), + }; + if metadata.file_type().is_symlink() || !metadata.is_file() { + return Err(security(format!( + "{WORKSPACE_FILE}: the workspace file must be a regular file" + ))); + } + let bytes = std::fs::read(file.as_std_path()) + .map_err(|io_error| workspace_error(format!("{WORKSPACE_FILE}: {io_error}")))?; + let text = std::str::from_utf8(&bytes) + .map_err(|_| workspace_error(format!("{WORKSPACE_FILE} is not UTF-8")))?; + if toml_comment_at(text).is_some() { + return Err(workspace_error(format!( + "{WORKSPACE_FILE}: comments are forbidden" + ))); + } + let raw: RawWorkspace = toml::from_str(text) + .map_err(|error| workspace_error(format!("{WORKSPACE_FILE}: {error}")))?; + if raw.spec != WORKSPACE_SPEC { + return Err(workspace_error(format!( + "{WORKSPACE_FILE}: unsupported workspace schema `{}`", + raw.spec + ))); + } + for member in &raw.members { + if !is_project_relative(member) { + return Err(workspace_error(format!( + "{WORKSPACE_FILE}: member `{member}` is not a relative directory of the workspace" + ))); + } + } + if !raw.members.windows(2).all(|pair| pair[0] < pair[1]) { + return Err(workspace_error(format!( + "{WORKSPACE_FILE}: members must be unique and sorted" + ))); + } + Ok(Some(Self { + root: directory.to_path_buf(), + members: raw.members, + })) + } + + /// The workspace of a project: the nearest ancestor of its canonical root + /// that holds a workspace file, which must list the project's own + /// directory. A project is not a member of the workspace of its own + /// directory, and a stray file higher up grants nothing to a project it + /// does not list. + pub fn of_project(root: &Utf8Path) -> Result { + let mut current = root.parent(); + while let Some(directory) = current { + if let Some(workspace) = Self::read(directory)? { + if workspace.member_of(root).is_none() { + return Err(workspace_error(format!( + "the project is not a member of its workspace: {WORKSPACE_FILE} does not list its directory" + ))); + } + return Ok(workspace); + } + current = directory.parent(); + } + Err(workspace_error(format!( + "a project outside any workspace cannot declare a source package: no ancestor directory holds a {WORKSPACE_FILE}" + ))) + } + + /// The member directory (workspace-relative) of a project root beneath + /// this workspace, when it is a listed member. + #[must_use] + pub fn member_of(&self, root: &Utf8Path) -> Option { + let relative = + crate::project::project_relative(root.strip_prefix(&self.root).ok()?.as_str()); + self.members.contains(&relative).then_some(relative) + } +} + +/// One source package read from its member directory and verified against +/// the rules of §10.5. +#[derive(Debug, Clone)] +pub struct ResolvedSourcePackage { + /// The identifier the declaration gave it. + pub id: String, + /// The declared version. + pub version: String, + /// The workspace-relative member directory. + pub member: String, + /// Its module prefix, the first thing its modules are named under. + pub prefix: String, + /// Its parsed manifest. + pub config: ProjectConfig, + /// The tree digest over its manifest and source files. + pub tree_sha256: Sha256Digest, + /// The digest of its manifest bytes. + pub manifest_sha256: Sha256Digest, + /// The identifiers of the packages its manifest declares, sorted. + pub dependencies: Vec, + /// Every file the tree digest covers beneath the member, by + /// member-relative path. + pub files: BTreeMap>, + /// Its modules by name relative to its source roots, with the + /// member-relative path of the file that declares each. + pub modules: BTreeMap, +} + +impl ResolvedSourcePackage { + /// The key of one of its modules in a project that imports it: the Lean + /// name the module has, its prefix and its relative name (§10.5). + #[must_use] + pub fn key(&self, relative_name: &str) -> String { + format!("{}.{relative_name}", self.prefix) + } + + /// The display path of one of its files in diagnostics and records. + #[must_use] + pub fn display_path(&self, member_relative: &str) -> String { + format!("{}:{member_relative}", self.id) + } +} + +/// Every source package a project's closure reaches, by identifier. +#[derive(Debug, Clone, Default)] +pub struct SourcePackages { + /// The packages, by identifier. + pub packages: BTreeMap, + /// The identifiers the project declares itself, sorted. + pub declared: Vec, +} + +impl SourcePackages { + /// The lock rows of the closure, sorted by identifier (§11.1). + #[must_use] + pub fn rows(&self) -> Vec { + self.packages + .values() + .map(|package| LockSourcePackage { + id: package.id.clone(), + version: package.version.clone(), + kind: "path".to_owned(), + source: package.member.clone(), + module_prefix: package.prefix.clone(), + tree_sha256: package.tree_sha256, + manifest_sha256: package.manifest_sha256, + imports: package + .dependencies + .iter() + .map(|dependency| format!("{dependency}@{}", self.packages[dependency].version)) + .collect(), + }) + .collect() + } + + /// Whether the project reaches no source package. + #[must_use] + pub fn is_empty(&self) -> bool { + self.packages.is_empty() + } + + /// The package that owns a module key of the importing project, with the + /// module's name relative to the package's source roots. + #[must_use] + pub fn owner_of_key<'a>( + &'a self, + key: &'a str, + ) -> Option<(&'a ResolvedSourcePackage, &'a str)> { + self.packages.values().find_map(|package| { + let relative = key + .strip_prefix(package.prefix.as_str())? + .strip_prefix('.')?; + package + .modules + .contains_key(relative) + .then_some((package, relative)) + }) + } +} + +/// Is `prefix` equal to `other` or a dotted extension of it, either way? +fn prefixes_overlap(prefix: &str, other: &str) -> bool { + prefix == other + || prefix + .strip_prefix(other) + .is_some_and(|rest| rest.starts_with('.')) + || other + .strip_prefix(prefix) + .is_some_and(|rest| rest.starts_with('.')) +} + +/// Walk `member` beneath the workspace root with `symlink_metadata`, refusing +/// any symlink component, and require the last component to be a directory. +fn confined_member(workspace: &Workspace, member: &str) -> Result { + if !is_project_relative(member) { + return Err(security(format!("`{member}` escapes the workspace"))); + } + let mut current = workspace.root.clone(); + let mut walked = String::new(); + for segment in member.split('/') { + current.push(segment); + if !walked.is_empty() { + walked.push('/'); + } + walked.push_str(segment); + let metadata = std::fs::symlink_metadata(current.as_std_path()) + .map_err(|io_error| workspace_error(format!("`{walked}`: {io_error}")))?; + if metadata.file_type().is_symlink() { + return Err(security(format!( + "`{walked}`: symlinks are rejected in the path of a source package" + ))); + } + } + let metadata = std::fs::symlink_metadata(current.as_std_path()) + .map_err(|io_error| workspace_error(format!("`{member}`: {io_error}")))?; + if !metadata.is_dir() { + return Err(workspace_error(format!( + "`{member}` is not a directory of the workspace" + ))); + } + Ok(current) +} + +/// Read one regular file of a package, bounded by `max_file_bytes`. +fn read_file( + absolute: &Utf8Path, + shown: &str, + limits: &Limits, +) -> Result, Vec> { + let metadata = std::fs::symlink_metadata(absolute.as_std_path()) + .map_err(|io_error| vec![workspace_error(format!("{shown}: {io_error}"))])?; + if metadata.file_type().is_symlink() { + return Err(vec![security(format!( + "`{shown}`: symlinks are rejected in a source package" + ))]); + } + if !metadata.is_file() { + return Err(vec![security(format!( + "`{shown}`: special files are rejected in a source package" + ))]); + } + if metadata.len() > limits.max_file_bytes { + return Err(vec![Diagnostic::new( + code!("LLS8002"), + format!( + "max_file_bytes exceeded: configured {}, observed {} in {shown}", + limits.max_file_bytes, + metadata.len() + ), + )]); + } + std::fs::read(absolute.as_std_path()) + .map_err(|io_error| vec![workspace_error(format!("{shown}: {io_error}"))]) +} + +/// The modules of a package by name relative to its source roots (§10.5), +/// with the same duplicate and case-fold rules as a project's own (§23.3). +fn package_modules( + id: &str, + config: &ProjectConfig, + files: &BTreeMap>, +) -> Result, Vec> { + let mut diagnostics = Vec::new(); + let mut modules: BTreeMap = BTreeMap::new(); + for root in &config.source_roots { + let prefix = format!("{root}/"); + for path in files.keys() { + let Some(inside) = path.strip_prefix(&prefix) else { + continue; + }; + let Some(stem) = inside.strip_suffix(".lex.tex") else { + continue; + }; + let name = stem.replace('/', "."); + if !name.split('.').all(is_module_segment) { + diagnostics.push(config_error(format!( + "source package `{id}`: `{path}` is not a valid module path" + ))); + continue; + } + if let Some(existing) = modules.get(&name) { + diagnostics.push(Diagnostic::new( + code!("LLC0104"), + format!( + "source package `{id}`: `{path}` and `{existing}` declare the same module `{name}`" + ), + )); + continue; + } + modules.insert(name, path.clone()); + } + } + let mut folded: BTreeMap = BTreeMap::new(); + for module in modules.keys() { + if let Some(existing) = folded.insert(module.to_lowercase(), module) { + diagnostics.push(Diagnostic::new( + code!("LLC0104"), + format!( + "source package `{id}`: modules `{existing}` and `{module}` collide under case folding" + ), + )); + } + } + if diagnostics.is_empty() { + Ok(modules) + } else { + Err(diagnostics) + } +} + +/// Read one member as a source package: its manifest, its source roots, and +/// nothing else (§25.1). +fn load_member( + workspace: &Workspace, + id: &str, + version: &str, + member: &str, + limits: &Limits, +) -> Result> { + if !workspace.members.iter().any(|listed| listed == member) { + return Err(vec![workspace_error(format!( + "source package `{id}`: `{member}` is not a member of the workspace; {WORKSPACE_FILE} lists the directories a source package may name" + ))]); + } + let directory = confined_member(workspace, member).map_err(|d| vec![d])?; + let manifest_name = format!("{member}/lexlean.toml"); + let manifest_bytes = read_file(&directory.join("lexlean.toml"), &manifest_name, limits)?; + let config = parse_project(&manifest_name, &manifest_bytes)?; + let mut policy = Vec::new(); + if config.language != crate::LANGUAGE_1_2 { + policy.push(config_error(format!( + "source package `{id}`: {manifest_name} is language {}, and a source package is a language-1.2 project", + config.language + ))); + } + if !config.artifact_sources.is_empty() { + policy.push(config_error(format!( + "source package `{id}`: {manifest_name} declares artifact_source, which a package may not: its files would lie outside the pin" + ))); + } + if config.pdf.is_some() { + policy.push(config_error(format!( + "source package `{id}`: {manifest_name} declares a pdf provider, which a package may not" + ))); + } + if config + .lexicon_sources + .iter() + .any(|source| !matches!(source, LexiconSource::Builtin { .. })) + { + policy.push(config_error(format!( + "source package `{id}`: {manifest_name} declares a lexicon source other than a builtin one; its glossaries are those of the importing project" + ))); + } + if !policy.is_empty() { + return Err(policy); + } + let mut files: BTreeMap> = BTreeMap::new(); + files.insert("lexlean.toml".to_owned(), manifest_bytes.clone()); + for root in &config.source_roots { + let absolute_root = confined_member( + &Workspace { + root: workspace.root.clone(), + members: Vec::new(), + }, + &format!("{member}/{root}"), + ) + .map_err(|d| vec![d])?; + for entry in walkdir::WalkDir::new(absolute_root.as_std_path()) + .follow_links(false) + .sort_by_file_name() + { + let entry = entry + .map_err(|walk_error| vec![security(format!("`{member}/{root}`: {walk_error}"))])?; + let file_type = entry.file_type(); + if file_type.is_dir() { + continue; + } + let absolute = crate::project::utf8_path(entry.path()).map_err(|d| vec![d])?; + let relative = absolute + .strip_prefix(&directory) + .map(|inside| crate::project::project_relative(inside.as_str())) + .map_err(|_| vec![security(format!("`{member}/{root}` escapes the package"))])?; + let bytes = read_file(&absolute, &format!("{member}/{relative}"), limits)?; + files.insert(relative, bytes); + } + } + let rows: Vec<(&str, &[u8])> = files + .iter() + .map(|(path, bytes)| (path.as_str(), bytes.as_slice())) + .collect(); + let mut sorted = rows; + sorted.sort_by(|a, b| a.0.as_bytes().cmp(b.0.as_bytes())); + let tree_sha256 = tree_digest(&sorted); + let modules = package_modules(id, &config, &files)?; + Ok(ResolvedSourcePackage { + id: id.to_owned(), + version: version.to_owned(), + member: member.to_owned(), + prefix: config.module_prefix.clone(), + manifest_sha256: Sha256Digest::of(&manifest_bytes), + dependencies: config + .source_packages + .iter() + .map(|package| package.package.clone()) + .collect(), + config, + tree_sha256, + files, + modules, + }) +} + +/// Resolve every source package a project declares, with the packages theirs +/// declare in turn, from the member directories of its workspace (§10.5). +/// Nothing here reads outside a package's manifest and source roots, and +/// nothing is fetched. +/// +/// # Errors +/// +/// `LLC0108` for a workspace rule, `LLS8001` for a symlink or an escaping +/// path, `LLC0106` for an identifier with two sources, `LLR3003` for a +/// package that reaches itself, `LLC0107` for a module prefix two sources +/// claim, and the configuration errors of a manifest. +pub fn resolve(project: &Project) -> Result> { + if project.config.source_packages.is_empty() { + return Ok(SourcePackages::default()); + } + let Some(workspace) = &project.workspace else { + return Err(vec![workspace_error( + "a project outside any workspace cannot declare a source package", + )]); + }; + let own_member = project.workspace_member.clone(); + let limits = &project.config.limits; + let mut found: BTreeMap = BTreeMap::new(); + let mut work: Vec<(String, String, String)> = project + .config + .source_packages + .iter() + .map(|package| { + ( + package.package.clone(), + package.version.clone(), + package.path.clone(), + ) + }) + .collect(); + let mut diagnostics = Vec::new(); + while let Some((id, version, member)) = work.pop() { + if let Some(existing) = found.get(&id) { + if existing.member != member || existing.version != version { + diagnostics.push(Diagnostic::new( + code!("LLC0106"), + format!( + "source package `{id}` is declared with two sources: `{}` at {} and `{member}` at {version}", + existing.member, existing.version + ), + )); + } + continue; + } + if own_member.as_deref() == Some(member.as_str()) { + diagnostics.push(Diagnostic::new( + code!("LLR3003"), + format!("source package `{id}` names the importing project itself (`{member}`)"), + )); + continue; + } + match load_member(workspace, &id, &version, &member, limits) { + Ok(package) => { + for dependency in &package.config.source_packages { + work.push(( + dependency.package.clone(), + dependency.version.clone(), + dependency.path.clone(), + )); + } + found.insert(id, package); + } + Err(mut errors) => diagnostics.append(&mut errors), + } + } + if !diagnostics.is_empty() { + return Err(diagnostics); + } + let declared: Vec = project + .config + .source_packages + .iter() + .map(|package| package.package.clone()) + .collect(); + let packages = SourcePackages { + packages: found, + declared, + }; + check_acyclic(&packages)?; + check_prefixes(project, &packages)?; + Ok(packages) +} + +/// A package that reaches itself through the packages it declares is an +/// import cycle (§15.1). +fn check_acyclic(packages: &SourcePackages) -> Result<(), Vec> { + fn visit<'a>( + id: &'a str, + packages: &'a SourcePackages, + state: &mut BTreeMap<&'a str, u8>, + ) -> Result<(), String> { + match state.get(id) { + Some(1) => return Err(id.to_owned()), + Some(2) => return Ok(()), + _ => {} + } + state.insert(id, 1); + if let Some(package) = packages.packages.get(id) { + for dependency in &package.dependencies { + visit(dependency, packages, state)?; + } + } + state.insert(id, 2); + Ok(()) + } + let mut state = BTreeMap::new(); + for id in packages.packages.keys() { + visit(id, packages, &mut state).map_err(|cycle| { + vec![Diagnostic::new( + code!("LLR3003"), + format!("source packages depend on each other through `{cycle}`"), + )] + })?; + } + Ok(()) +} + +/// A module prefix is claimed by one source (§10.5): the project's own and +/// every package's must not be equal, and none may lie beneath another. +fn check_prefixes(project: &Project, packages: &SourcePackages) -> Result<(), Vec> { + let mut claims: Vec<(String, String)> = vec![( + project.config.module_prefix.clone(), + "the importing project".to_owned(), + )]; + claims.extend(packages.packages.values().map(|package| { + ( + package.prefix.clone(), + format!("source package `{}`", package.id), + ) + })); + let mut diagnostics = Vec::new(); + for (index, (prefix, owner)) in claims.iter().enumerate() { + for (other_prefix, other_owner) in &claims[index + 1..] { + if prefixes_overlap(prefix, other_prefix) { + diagnostics.push(Diagnostic::new( + code!("LLC0107"), + format!( + "the module prefix `{prefix}` of {owner} and the module prefix `{other_prefix}` of {other_owner} overlap: a module prefix is claimed by one source" + ), + )); + } + } + } + if diagnostics.is_empty() { + Ok(()) + } else { + Err(diagnostics) + } +} + +/// Compare the pins of a lock with the packages as they are now (§11.1): a +/// package whose version, source, prefix, or digests differ is `LLC0105`, naming +/// the package and both digests; a package the lock pins that the project's +/// closure does not reach is `LLC0106`. A package the closure reaches that the +/// lock lacks is left to the staleness of the lock as a whole. +/// +/// # Errors +/// +/// The diagnostics above. +pub fn check_pins( + locked: &[LockSourcePackage], + expected: &[LockSourcePackage], +) -> Result<(), Vec> { + let mut diagnostics = Vec::new(); + for row in locked { + match expected.iter().find(|candidate| candidate.id == row.id) { + None => diagnostics.push(Diagnostic::new( + code!("LLC0106"), + format!( + "the lock pins source package `{}`, which the project does not declare", + row.id + ), + )), + Some(current) if current != row => { + let mut differences = Vec::new(); + if row.version != current.version { + differences.push(format!( + "version: locked {}, found {}", + row.version, current.version + )); + } + if row.source != current.source { + differences.push(format!( + "source: locked {}, found {}", + row.source, current.source + )); + } + if row.module_prefix != current.module_prefix { + differences.push(format!( + "module_prefix: locked {}, found {}", + row.module_prefix, current.module_prefix + )); + } + if row.tree_sha256 != current.tree_sha256 { + differences.push(format!( + "tree_sha256: locked {}, found {}", + row.tree_sha256.to_hex(), + current.tree_sha256.to_hex() + )); + } + if row.manifest_sha256 != current.manifest_sha256 { + differences.push(format!( + "manifest_sha256: locked {}, found {}", + row.manifest_sha256.to_hex(), + current.manifest_sha256.to_hex() + )); + } + if row.imports != current.imports { + differences.push(format!( + "imports: locked [{}], found [{}]", + row.imports.join(", "), + current.imports.join(", ") + )); + } + diagnostics.push(Diagnostic::new( + code!("LLC0105"), + format!( + "source package `{}` is not the package the lock pins: {}", + row.id, + differences.join("; ") + ), + )); + } + Some(_) => {} + } + } + if diagnostics.is_empty() { + Ok(()) + } else { + Err(diagnostics) + } +} + +/// Resolve the source packages and require them to be the ones `lock` pins: +/// every command that links recomputes the digests (§11.1). +/// +/// # Errors +/// +/// Those of [`resolve`] and [`check_pins`], and `LLC0102` for a package the +/// closure reaches that the lock does not pin. +pub fn load_locked(project: &Project, lock: &Lock) -> Result> { + let packages = resolve(project)?; + let expected = packages.rows(); + check_pins(&lock.source_packages, &expected)?; + let pinned: BTreeSet<&str> = lock + .source_packages + .iter() + .map(|row| row.id.as_str()) + .collect(); + if let Some(missing) = expected + .iter() + .find(|row| !pinned.contains(row.id.as_str())) + { + return Err(vec![Diagnostic::new( + code!("LLC0102"), + format!( + "{} does not pin source package `{}`; run `lexlean lock`", + project.config.lockfile, missing.id + ), + )]); + } + Ok(packages) +} diff --git a/crates/lexlean/src/verify/mod.rs b/crates/lexlean/src/verify/mod.rs index 984a0f8bd..5497ec676 100644 --- a/crates/lexlean/src/verify/mod.rs +++ b/crates/lexlean/src/verify/mod.rs @@ -2861,6 +2861,22 @@ pub fn run_part( ), ("declarations", Json::Arr(declaration_rows)), ]; + // §10.5: the modules of a source package carry the package as their + // origin, keyed by their Lean module. + let origins: Vec<(&str, Json)> = build + .modules + .iter() + .filter_map(|module| { + checked.modules[&module.module] + .document + .origin + .as_ref() + .map(|origin| (module.lean_module.as_str(), Json::Str(origin.clone()))) + }) + .collect(); + if !origins.is_empty() { + body_fields.push(("origins", Json::object(origins))); + } if let Some(row) = compiler_input_row { body_fields.push(("compiler_input", row)); } diff --git a/features/suites/packages.feature b/features/suites/packages.feature new file mode 100644 index 000000000..d89aa6e73 --- /dev/null +++ b/features/suites/packages.feature @@ -0,0 +1,31 @@ +Feature: packages + + Source packages: a project imports the modules of a locked, content-addressed package of its workspace (§10.5). + + @PK-01 @build + Scenario: A language-1.2 project that declares a source package by its identifier, version, kind `path`, and the member directory a `lexlean-workspace.toml` lists locks it by the tree digest of its manifest and source files, its manifest digest, its version, its module prefix, and its own packages, and the configuration and the lock read back to the bytes written; a project without a source package keeps its bytes, and a package of another kind, a source package in another language, a changed byte or version (LLC0105), an undeclared package (LLC0106), a module prefix claimed twice (LLC0107), a project or a package outside the workspace (LLC0108), a path that escapes it, and a symlink (LLS8001) are each refused with the named code. + Given a workspace of an importing project and a package, and the lock that pins the package + When the configuration and the lock are written, read back, and locked again, and the package, the workspace, and the configuration are each edited in the six ways the statement names + Then the bytes read back equal the bytes written, and a project without a source package locks to the bytes it locked to before + And each edit is refused with the code the statement names, naming the package and both digests for a changed byte or version + + @PK-02 @build + Scenario: A module of a project imports only modules of its own project and modules of the packages the project declares, and a module of a package only modules of itself and of the packages its own manifest declares: a package module is a module of the importing project under its own module prefix, a module of a package the project does not declare fails with LLR3009, and an import cycle through a package fails with LLR3003. + Given an importing project, a package, and a package that imports a second package + When the project is checked, then with the import of the second package moved to the project, then with a module importing a package it does not declare, then with a cycle through the package + Then the closure links, and each package module is a module of the project under the package's module prefix + And the undeclared import fails with LLR3009 and the cycle with LLR3003 + + @PK-03 @build + Scenario: An importing project builds and verifies under the pinned Lean offline, and its package modules are generated, elaborated, replayed with `leanchecker`, and audited for their exact axioms under the package's module prefix with the package as their origin in the records; the source ID of the project changes with the pins, and no file of the package is written by `fmt`, `build`, or `verify`. + Given an importing project and a package beside it in a workspace + When the project is formatted, built, and verified with the pinned Lean, and again with one byte of the package changed + Then the verification records name the package modules under its prefix with the package as their origin, the exact axioms of each declaration are audited, and no file of the package changed + And the changed byte is refused before any Lean process runs + + @PK-04 @build + Scenario: A production root of the importing project whose closure reaches a definition of a package certifies and exports over that closure as it does for a definition of its own module, the `production:` roots of a package are not roots of the importing project, and the importer publishes no certificate of the package's own. + Given an importing project with a production root that applies a definition of a package whose own modules declare production roots + When the project is checked, built, and its root is certified and exported with the pinned Lean + Then the root's closure includes the package definition and the export is the package of that closure + And no root of the package is a root of the importing project and the export holds no certificate of the package's own roots diff --git a/model/errors.toml b/model/errors.toml index 0d9f6d202..ee9b5122e 100644 --- a/model/errors.toml +++ b/model/errors.toml @@ -98,6 +98,34 @@ exit = 2 title = "Duplicate module or case-folded path collision" statement = "Duplicate module or case-folded path collision." +[[error]] +code = "LLC0105" +class = "cli-configuration" +exit = 2 +title = "Source package is not the package the lock pins" +statement = "A source package's version, source, module prefix, manifest digest, tree digest, or declared packages differ from the lock's row, naming the package and both digests." + +[[error]] +code = "LLC0106" +class = "cli-configuration" +exit = 2 +title = "Source package undeclared or declared with two sources" +statement = "The lock pins a source package the project does not declare, or one identifier names two sources in the closure." + +[[error]] +code = "LLC0107" +class = "cli-configuration" +exit = 2 +title = "Module prefix claimed by two sources" +statement = "A module prefix is claimed by the project and a source package, or by two source packages, equal or one beneath the other, or an import names a module both the project and a package provide." + +[[error]] +code = "LLC0108" +class = "cli-configuration" +exit = 2 +title = "Source package outside the workspace rule" +statement = "A project that declares a source package is outside any workspace or is not a member of it, a package is not a member of the workspace, or the workspace file or a package is malformed." + [[error]] code = "LLC0201" class = "cli-configuration" @@ -294,6 +322,13 @@ exit = 1 title = "Model artifact bytes violate the declared schema, type, or role" statement = "Model artifact bytes violate the declared schema, type, or role." +[[error]] +code = "LLR3009" +class = "language" +exit = 1 +title = "Import of a module of a source package the importing scope does not declare" +statement = "A module imports a module of a source package that the project, or the package the module belongs to, does not declare." + [[error]] code = "LLS8001" class = "security-limit" diff --git a/model/ids.toml b/model/ids.toml index d6150a13f..76e246460 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -2361,3 +2361,27 @@ id = "RT-04" level = "build" suite = "runtime" statement = "No Lean runtime text remains in the language-1.2 compiler: a generated language-1.2 module imports the runtime modules whose constants it names and declares nothing under a runtime namespace, and the only Lean runtime text in the compiler's source outside unit-test items, in one string literal or in several written together, is the decoder of core module 2, which loads native modules and so cannot be one; a runtime text planted in any of its shapes, raw or escaped, with or without a namespace line, split across literals, or after a test module, is found." + +[[id]] +id = "PK-01" +level = "build" +suite = "packages" +statement = "A language-1.2 project that declares a source package by its identifier, version, kind `path`, and the member directory a `lexlean-workspace.toml` lists locks it by the tree digest of its manifest and source files, its manifest digest, its version, its module prefix, and its own packages, and the configuration and the lock read back to the bytes written; a project without a source package keeps its bytes, and a package of another kind, a source package in another language, a changed byte or version (LLC0105), an undeclared package (LLC0106), a module prefix claimed twice (LLC0107), a project or a package outside the workspace (LLC0108), a path that escapes it, and a symlink (LLS8001) are each refused with the named code." + +[[id]] +id = "PK-02" +level = "build" +suite = "packages" +statement = "A module of a project imports only modules of its own project and modules of the packages the project declares, and a module of a package only modules of itself and of the packages its own manifest declares: a package module is a module of the importing project under its own module prefix, a module of a package the project does not declare fails with LLR3009, and an import cycle through a package fails with LLR3003." + +[[id]] +id = "PK-03" +level = "build" +suite = "packages" +statement = "An importing project builds and verifies under the pinned Lean offline, and its package modules are generated, elaborated, replayed with `leanchecker`, and audited for their exact axioms under the package's module prefix with the package as their origin in the records; the source ID of the project changes with the pins, and no file of the package is written by `fmt`, `build`, or `verify`." + +[[id]] +id = "PK-04" +level = "build" +suite = "packages" +statement = "A production root of the importing project whose closure reaches a definition of a package certifies and exports over that closure as it does for a definition of its own module, the `production:` roots of a package are not roots of the importing project, and the importer publishes no certificate of the package's own." diff --git a/schemas/attestation-v2.schema.json b/schemas/attestation-v2.schema.json index ae35f67b7..90622e1bb 100644 --- a/schemas/attestation-v2.schema.json +++ b/schemas/attestation-v2.schema.json @@ -1 +1 @@ -{"$id":"https://github.com/afflom/lexlean/schemas/attestation-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"attestation_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"build_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"build_manifest":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"compiler_input":{"additionalProperties":false,"properties":{"byte_length":{"minimum":1,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"declarations":{"items":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"observed":{"items":{"minLength":1,"type":"string"},"type":"array"},"policy":{"additionalProperties":false,"properties":{"axioms":{"items":{"minLength":1,"type":"string"},"type":"array"},"kind":{"enum":["none","allow","exact"]}},"required":["axioms","kind"],"type":"object"},"result":{"const":"ok"}},"required":["name","observed","policy","result"],"type":"object"},"type":"array"},"host":{"additionalProperties":false,"properties":{"arch":{"minLength":1,"type":"string"},"os":{"minLength":1,"type":"string"}},"required":["arch","os"],"type":"object"},"lake_workspace":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"lexlean":{"additionalProperties":false,"properties":{"compiler_semantics":{"pattern":"^[0-9a-f]{64}$","type":"string"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["compiler_semantics","executable_sha256","version"],"type":"object"},"oleans":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"module":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","module","sha256"],"type":"object"},"type":"array"},"pdf":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"compile":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"},"module":{"minLength":1,"type":"string"},"pdf_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"recipe_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"}},"required":["byte_length","compile","module","pdf_sha256","recipe_id","version"],"type":"object"},"type":"array"},"preservation":{"additionalProperties":false,"properties":{"byte_length":{"minimum":1,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"processes":{"items":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"},"type":"array"},"semantic_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"source_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"spec":{"const":"lexlean/attestation/2"},"status":{"const":"verified"},"toolchain":{"additionalProperties":false,"properties":{"lake":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"},"lean":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"},"leanchecker":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"}},"required":["lake","lean","leanchecker"],"type":"object"}},"required":["attestation_id","build_id","build_manifest","declarations","host","lake_workspace","lexlean","oleans","processes","semantic_id","source_id","spec","status","toolchain"],"title":"LexLean language-1.2 verification attestation (SPEC.md §22.9)","type":"object"} +{"$id":"https://github.com/afflom/lexlean/schemas/attestation-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"attestation_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"build_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"build_manifest":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"compiler_input":{"additionalProperties":false,"properties":{"byte_length":{"minimum":1,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"declarations":{"items":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"observed":{"items":{"minLength":1,"type":"string"},"type":"array"},"policy":{"additionalProperties":false,"properties":{"axioms":{"items":{"minLength":1,"type":"string"},"type":"array"},"kind":{"enum":["none","allow","exact"]}},"required":["axioms","kind"],"type":"object"},"result":{"const":"ok"}},"required":["name","observed","policy","result"],"type":"object"},"type":"array"},"host":{"additionalProperties":false,"properties":{"arch":{"minLength":1,"type":"string"},"os":{"minLength":1,"type":"string"}},"required":["arch","os"],"type":"object"},"lake_workspace":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"lexlean":{"additionalProperties":false,"properties":{"compiler_semantics":{"pattern":"^[0-9a-f]{64}$","type":"string"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["compiler_semantics","executable_sha256","version"],"type":"object"},"oleans":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"module":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","module","sha256"],"type":"object"},"type":"array"},"origins":{"additionalProperties":{"minLength":1,"type":"string"},"type":"object"},"pdf":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"compile":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"},"module":{"minLength":1,"type":"string"},"pdf_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"recipe_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"}},"required":["byte_length","compile","module","pdf_sha256","recipe_id","version"],"type":"object"},"type":"array"},"preservation":{"additionalProperties":false,"properties":{"byte_length":{"minimum":1,"type":"integer"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","sha256"],"type":"object"},"processes":{"items":{"additionalProperties":false,"properties":{"argv":{"items":{"type":"string"},"type":"array"},"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"exit_code":{"type":"integer"},"module":{"minLength":1,"type":"string"},"stderr":{"type":"string"},"stderr_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"stdout":{"type":"string"},"stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"tool":{"enum":["lean","lake","leanchecker","pdf"]}},"required":["argv","executable_sha256","exit_code","stderr","stderr_sha256","stdout","stdout_sha256","tool"],"type":"object"},"type":"array"},"semantic_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"source_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"spec":{"const":"lexlean/attestation/2"},"status":{"const":"verified"},"toolchain":{"additionalProperties":false,"properties":{"lake":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"},"lean":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"},"leanchecker":{"additionalProperties":false,"properties":{"executable_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version_output":{"type":"string"}},"required":["executable_sha256","version_output"],"type":"object"}},"required":["lake","lean","leanchecker"],"type":"object"}},"required":["attestation_id","build_id","build_manifest","declarations","host","lake_workspace","lexlean","oleans","processes","semantic_id","source_id","spec","status","toolchain"],"title":"LexLean language-1.2 verification attestation (SPEC.md §22.9)","type":"object"} diff --git a/schemas/build-manifest-v2.schema.json b/schemas/build-manifest-v2.schema.json index 60230cca0..330c54312 100644 --- a/schemas/build-manifest-v2.schema.json +++ b/schemas/build-manifest-v2.schema.json @@ -1 +1 @@ -{"$id":"https://github.com/afflom/lexlean/schemas/build-manifest-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"build_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"compiler":{"additionalProperties":false,"properties":{"semantics_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["semantics_id","version"],"type":"object"},"inputs":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"kind":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","kind","path","sha256"],"type":"object"},"type":"array"},"language":{"enum":["1.1","1.2"]},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"modules":{"items":{"additionalProperties":false,"properties":{"lean_module":{"minLength":1,"type":"string"},"module":{"minLength":1,"type":"string"},"source_path":{"minLength":1,"type":"string"}},"required":["lean_module","module","source_path"],"type":"object"},"type":"array"},"outputs":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"kind":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","kind","path","sha256"],"type":"object"},"type":"array"},"project":{"minLength":1,"type":"string"},"selection":{"items":{"minLength":1,"type":"string"},"type":"array"},"semantic_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"source_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"spec":{"const":"lexlean/build-manifest/1"}},"required":["build_id","compiler","inputs","language","lean_toolchain","modules","outputs","project","selection","semantic_id","source_id","spec"],"title":"LexLean build manifest for languages 1.1 and 1.2 (SPEC.md §21.6)","type":"object"} +{"$id":"https://github.com/afflom/lexlean/schemas/build-manifest-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"build_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"compiler":{"additionalProperties":false,"properties":{"semantics_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["semantics_id","version"],"type":"object"},"inputs":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"kind":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","kind","path","sha256"],"type":"object"},"type":"array"},"language":{"enum":["1.1","1.2"]},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"modules":{"items":{"additionalProperties":false,"properties":{"lean_module":{"minLength":1,"type":"string"},"module":{"minLength":1,"type":"string"},"origin":{"minLength":1,"type":"string"},"source_path":{"minLength":1,"type":"string"}},"required":["lean_module","module","source_path"],"type":"object"},"type":"array"},"outputs":{"items":{"additionalProperties":false,"properties":{"byte_length":{"minimum":0,"type":"integer"},"kind":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["byte_length","kind","path","sha256"],"type":"object"},"type":"array"},"project":{"minLength":1,"type":"string"},"selection":{"items":{"minLength":1,"type":"string"},"type":"array"},"semantic_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"source_id":{"pattern":"^[0-9a-f]{64}$","type":"string"},"spec":{"const":"lexlean/build-manifest/1"}},"required":["build_id","compiler","inputs","language","lean_toolchain","modules","outputs","project","selection","semantic_id","source_id","spec"],"title":"LexLean build manifest for languages 1.1 and 1.2 (SPEC.md §21.6)","type":"object"} diff --git a/schemas/lock-v2.schema.json b/schemas/lock-v2.schema.json index 863b87df4..3c708f7e2 100644 --- a/schemas/lock-v2.schema.json +++ b/schemas/lock-v2.schema.json @@ -1 +1 @@ -{"$id":"https://github.com/afflom/lexlean/schemas/lock-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"compiler_semantics":{"pattern":"^[0-9a-f]{64}$","type":"string"},"language":{"const":"1.2"},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"package":{"items":{"additionalProperties":false,"properties":{"id":{"minLength":1,"type":"string"},"imports":{"items":{"minLength":1,"type":"string"},"type":"array"},"kind":{"enum":["builtin","path","git"]},"manifest_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"revision":{"minLength":1,"type":"string"},"source":{"minLength":1,"type":"string"},"tree_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["id","imports","kind","manifest_sha256","revision","source","tree_sha256","version"],"type":"object"},"type":"array"},"pdf":{"additionalProperties":false,"properties":{"compile_argv":{"items":{"type":"string"},"type":"array"},"output":{"minLength":1,"type":"string"},"program":{"minLength":1,"type":"string"},"program_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resource":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"version_argv":{"items":{"type":"string"},"type":"array"},"version_stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["compile_argv","output","program","program_sha256","resource","version_argv","version_stdout_sha256"],"type":"object"},"project_config_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"spec":{"const":"lexlean/lock/2"},"workspace_file":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"}},"required":["compiler_semantics","language","lean_toolchain","package","project_config_sha256","spec","workspace_file"],"title":"LexLean lock file lexlean.lock v2 (SPEC.md §11)","type":"object"} +{"$id":"https://github.com/afflom/lexlean/schemas/lock-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"compiler_semantics":{"pattern":"^[0-9a-f]{64}$","type":"string"},"language":{"const":"1.2"},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"package":{"items":{"additionalProperties":false,"properties":{"id":{"minLength":1,"type":"string"},"imports":{"items":{"minLength":1,"type":"string"},"type":"array"},"kind":{"enum":["builtin","path","git"]},"manifest_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"revision":{"minLength":1,"type":"string"},"source":{"minLength":1,"type":"string"},"tree_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["id","imports","kind","manifest_sha256","revision","source","tree_sha256","version"],"type":"object"},"type":"array"},"pdf":{"additionalProperties":false,"properties":{"compile_argv":{"items":{"type":"string"},"type":"array"},"output":{"minLength":1,"type":"string"},"program":{"minLength":1,"type":"string"},"program_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resource":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"version_argv":{"items":{"type":"string"},"type":"array"},"version_stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["compile_argv","output","program","program_sha256","resource","version_argv","version_stdout_sha256"],"type":"object"},"project_config_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"source_package":{"items":{"additionalProperties":false,"properties":{"id":{"minLength":1,"type":"string"},"imports":{"items":{"minLength":1,"type":"string"},"type":"array"},"kind":{"const":"path"},"manifest_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"module_prefix":{"minLength":1,"type":"string"},"source":{"minLength":1,"type":"string"},"tree_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"version":{"minLength":1,"type":"string"}},"required":["id","imports","kind","manifest_sha256","module_prefix","source","tree_sha256","version"],"type":"object"},"type":"array"},"spec":{"const":"lexlean/lock/2"},"workspace_file":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"}},"required":["compiler_semantics","language","lean_toolchain","package","project_config_sha256","spec","workspace_file"],"title":"LexLean lock file lexlean.lock v2 (SPEC.md §11)","type":"object"} diff --git a/schemas/project-v2.schema.json b/schemas/project-v2.schema.json index 7912dec0a..534f07da2 100644 --- a/schemas/project-v2.schema.json +++ b/schemas/project-v2.schema.json @@ -1 +1 @@ -{"$id":"https://github.com/afflom/lexlean/schemas/project-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"artifact_source":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"build_root":{"minLength":1,"type":"string"},"entrypoints":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array"},"language":{"enum":["1.1","1.2"]},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"lean_workspace":{"minLength":1,"type":"string"},"lexicon_source":{"items":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"builtin"},"package":{"minLength":1,"type":"string"}},"required":["kind","package"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"path"},"package":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"}},"required":["kind","package","path"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"git"},"package":{"minLength":1,"type":"string"},"revision":{"pattern":"^[0-9a-f]{40}$","type":"string"},"subdirectory":{"minLength":1,"type":"string"},"url":{"minLength":1,"type":"string"}},"required":["kind","package","revision","subdirectory","url"],"type":"object"}]},"type":"array"},"limits":{"additionalProperties":false,"properties":{"child_timeout_ms":{"minimum":1,"type":"integer"},"max_child_output_bytes":{"minimum":1,"type":"integer"},"max_diagnostics":{"minimum":1,"type":"integer"},"max_file_bytes":{"minimum":1,"type":"integer"},"max_import_depth":{"minimum":1,"type":"integer"},"max_ir_nodes":{"minimum":1,"type":"integer"},"max_parse_states":{"minimum":1,"type":"integer"},"max_primitive_atoms":{"minimum":1,"type":"integer"},"max_scope_depth":{"minimum":1,"type":"integer"},"max_token_lattice_edges":{"minimum":1,"type":"integer"},"max_total_source_bytes":{"minimum":1,"type":"integer"}},"required":["child_timeout_ms","max_child_output_bytes","max_diagnostics","max_file_bytes","max_import_depth","max_ir_nodes","max_parse_states","max_primitive_atoms","max_scope_depth","max_token_lattice_edges","max_total_source_bytes"],"type":"object"},"lockfile":{"minLength":1,"type":"string"},"module_prefix":{"pattern":"^[A-Z][A-Za-z0-9_]*(\\.[A-Z][A-Za-z0-9_]*)*$","type":"string"},"name":{"pattern":"^[a-z][a-z0-9-]{0,62}$","type":"string"},"pdf":{"additionalProperties":false,"properties":{"compile_argv":{"items":{"type":"string"},"type":"array"},"mode":{"const":"external"},"output":{"minLength":1,"type":"string"},"program":{"minLength":1,"type":"string"},"program_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resources":{"items":{"minLength":1,"type":"string"},"type":"array"},"version_argv":{"items":{"type":"string"},"type":"array"},"version_stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["compile_argv","mode","output","program","program_sha256","resources","version_argv","version_stdout_sha256"],"type":"object"},"source_roots":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array"},"spec":{"const":"lexlean/project/1"}},"required":["build_root","entrypoints","language","lean_toolchain","lean_workspace","lexicon_source","limits","lockfile","module_prefix","name","source_roots","spec"],"title":"LexLean project file lexlean.toml for languages 1.1 and 1.2 (SPEC.md §10.1)","type":"object"} +{"$id":"https://github.com/afflom/lexlean/schemas/project-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"artifact_source":{"items":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["path","sha256"],"type":"object"},"type":"array"},"build_root":{"minLength":1,"type":"string"},"entrypoints":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array"},"language":{"enum":["1.1","1.2"]},"lean_toolchain":{"const":"leanprover/lean4:v4.32.1"},"lean_workspace":{"minLength":1,"type":"string"},"lexicon_source":{"items":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"builtin"},"package":{"minLength":1,"type":"string"}},"required":["kind","package"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"path"},"package":{"minLength":1,"type":"string"},"path":{"minLength":1,"type":"string"}},"required":["kind","package","path"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"git"},"package":{"minLength":1,"type":"string"},"revision":{"pattern":"^[0-9a-f]{40}$","type":"string"},"subdirectory":{"minLength":1,"type":"string"},"url":{"minLength":1,"type":"string"}},"required":["kind","package","revision","subdirectory","url"],"type":"object"}]},"type":"array"},"limits":{"additionalProperties":false,"properties":{"child_timeout_ms":{"minimum":1,"type":"integer"},"max_child_output_bytes":{"minimum":1,"type":"integer"},"max_diagnostics":{"minimum":1,"type":"integer"},"max_file_bytes":{"minimum":1,"type":"integer"},"max_import_depth":{"minimum":1,"type":"integer"},"max_ir_nodes":{"minimum":1,"type":"integer"},"max_parse_states":{"minimum":1,"type":"integer"},"max_primitive_atoms":{"minimum":1,"type":"integer"},"max_scope_depth":{"minimum":1,"type":"integer"},"max_token_lattice_edges":{"minimum":1,"type":"integer"},"max_total_source_bytes":{"minimum":1,"type":"integer"}},"required":["child_timeout_ms","max_child_output_bytes","max_diagnostics","max_file_bytes","max_import_depth","max_ir_nodes","max_parse_states","max_primitive_atoms","max_scope_depth","max_token_lattice_edges","max_total_source_bytes"],"type":"object"},"lockfile":{"minLength":1,"type":"string"},"module_prefix":{"pattern":"^[A-Z][A-Za-z0-9_]*(\\.[A-Z][A-Za-z0-9_]*)*$","type":"string"},"name":{"pattern":"^[a-z][a-z0-9-]{0,62}$","type":"string"},"pdf":{"additionalProperties":false,"properties":{"compile_argv":{"items":{"type":"string"},"type":"array"},"mode":{"const":"external"},"output":{"minLength":1,"type":"string"},"program":{"minLength":1,"type":"string"},"program_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"resources":{"items":{"minLength":1,"type":"string"},"type":"array"},"version_argv":{"items":{"type":"string"},"type":"array"},"version_stdout_sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["compile_argv","mode","output","program","program_sha256","resources","version_argv","version_stdout_sha256"],"type":"object"},"source_package":{"items":{"additionalProperties":false,"properties":{"kind":{"const":"path"},"package":{"pattern":"^[a-z][a-z0-9-]{0,62}$","type":"string"},"path":{"minLength":1,"type":"string"},"version":{"pattern":"^[A-Za-z0-9][A-Za-z0-9.+-]{0,63}$","type":"string"}},"required":["kind","package","path","version"],"type":"object"},"type":"array"},"source_roots":{"items":{"minLength":1,"type":"string"},"minItems":1,"type":"array"},"spec":{"const":"lexlean/project/1"}},"required":["build_root","entrypoints","language","lean_toolchain","lean_workspace","lexicon_source","limits","lockfile","module_prefix","name","source_roots","spec"],"title":"LexLean project file lexlean.toml for languages 1.1 and 1.2 (SPEC.md §10.1)","type":"object"} diff --git a/schemas/semantic-snapshot-v2.schema.json b/schemas/semantic-snapshot-v2.schema.json index b3aad1008..c860817d2 100644 --- a/schemas/semantic-snapshot-v2.schema.json +++ b/schemas/semantic-snapshot-v2.schema.json @@ -1 +1 @@ -{"$defs":{"axiomPolicy":{"additionalProperties":false,"properties":{"axioms":{"items":{"type":"string"},"type":"array","uniqueItems":true},"kind":{"enum":["allow","exact","none"]}},"required":["axioms","kind"],"type":"object"},"crossCheck":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"theorem"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["kind","theorem","type_arguments"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"}]},"statement":{"oneOf":[{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"helper":{"minLength":1,"type":"string"},"kind":{"const":"helper"}},"required":["arguments","helper","kind"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["artifact","element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"lines"}},"required":["artifact","kind"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"bytes"}},"required":["artifact","kind"],"type":"object"}]},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["name","proof","statement","type_parameters"],"type":"object"},"declaration":{"additionalProperties":false,"properties":{"alpha_id":{"$ref":"#/$defs/digest"},"axiom_policy":{"$ref":"#/$defs/axiomPolicy"},"elaboration":{"$ref":"#/$defs/elaboration"},"kind":{"enum":["abbrev","artifact","class","constructor","contract","corollary","definition","evidence","inductive","inference_rule","instance","lemma","logic","model","predicatedefinition","realization","reasoner","recursor","structure","termdefinition","theorem","typedefinition","verifier"]},"lean_name":{"minLength":1,"type":"string"},"linked_ir":{"$ref":"#/$defs/semanticValue"},"logical_id":{"minLength":1,"type":"string"},"origin":{"$ref":"#/$defs/origin"}},"required":["axiom_policy","kind","lean_name","linked_ir","logical_id"],"type":"object"},"digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"elaboration":{"additionalProperties":false,"properties":{"alpha_ids":{"additionalProperties":{"$ref":"#/$defs/digest"},"type":"object"},"cross_checks":{"items":{"$ref":"#/$defs/crossCheck"},"type":"array"},"declarations":{"items":{"$ref":"#/$defs/elaboration_declaration"},"type":"array"},"obligations":{"items":{"$ref":"#/$defs/obligation"},"type":"array"},"required_checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array"},"theorems":{"items":{"$ref":"#/$defs/generatedTheorem"},"type":"array"}},"required":["alpha_ids","cross_checks","declarations","obligations","required_checks"],"type":"object"},"elaboration_artifactSchema":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"bytes"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"int_tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"utf8_lines"}},"required":["kind"],"type":"object"}]},"elaboration_assignment":{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/elaboration_name"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["field","value"],"type":"object"},"elaboration_branch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/elaboration_term"},"constructor":{"$ref":"#/$defs/elaboration_member"}},"required":["binders","body","constructor"],"type":"object"},"elaboration_claim":{"oneOf":[{"additionalProperties":false,"properties":{"agreements":{"minimum":0,"type":"integer"},"comparison":{"$ref":"#/$defs/elaboration_member"},"comparison_sound":{"$ref":"#/$defs/elaboration_member"},"dataset":{"$ref":"#/$defs/elaboration_member"},"examples":{"minimum":0,"type":"integer"},"kind":{"const":"dataset_agreement"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["agreements","comparison","comparison_sound","dataset","examples","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"equivalent_to"},"reference":{"$ref":"#/$defs/elaboration_modelUse"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","reference","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"preserves_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"satisfies_contract"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"}]},"elaboration_compositeForm":{"oneOf":[{"additionalProperties":false,"properties":{"junctions":{"items":{"$ref":"#/$defs/elaboration_compositeJunction"},"minItems":1,"type":"array"},"kind":{"const":"sequence"},"stages":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"minItems":2,"type":"array"}},"required":["junctions","kind","stages"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"fanout"},"left":{"$ref":"#/$defs/elaboration_modelUse"},"right":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/elaboration_modelUse"},"right":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"else":{"$ref":"#/$defs/elaboration_modelUse"},"guard":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"branch"},"then":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["else","guard","kind","then"],"type":"object"},{"additionalProperties":false,"properties":{"junction":{"$ref":"#/$defs/elaboration_compositeJunction"},"kind":{"const":"scan"},"stage":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["junction","kind","stage"],"type":"object"}]},"elaboration_compositeJunction":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"unconditional"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"evidence":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"proved"}},"required":["evidence","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"checked"}},"required":["kind"],"type":"object"}]},"elaboration_constructor":{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["fields","name"],"type":"object"},"elaboration_contractState":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"next":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","next","type"],"type":"object"},"elaboration_contractValidator":{"additionalProperties":false,"properties":{"complete":{"$ref":"#/$defs/elaboration_member"},"predicate":{"enum":["invariant","postcondition","precondition"]},"sound":{"$ref":"#/$defs/elaboration_member"},"validator":{"$ref":"#/$defs/elaboration_member"}},"required":["predicate","sound","validator"],"type":"object"},"elaboration_declaration":{"oneOf":[{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_field"},"minItems":1,"type":"array"},"kind":{"const":"structure"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_field"},"minItems":1,"type":"array"},"kind":{"const":"class"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"class":{"$ref":"#/$defs/elaboration_member"},"fields":{"items":{"$ref":"#/$defs/elaboration_assignment"},"minItems":1,"type":"array"},"kind":{"const":"instance"},"name":{"$ref":"#/$defs/elaboration_name"},"priority":{"const":1000}},"required":["arguments","class","fields","kind","name","priority"],"type":"object"},{"additionalProperties":false,"properties":{"constructors":{"items":{"$ref":"#/$defs/elaboration_constructor"},"minItems":1,"type":"array"},"kind":{"const":"inductive"},"mutual":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["constructors","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/elaboration_term"},"executable":{"type":"boolean"},"kind":{"const":"definition"},"mutual":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"production":{"$ref":"#/$defs/elaboration_production"},"recursive_argument":{"$ref":"#/$defs/elaboration_name"},"result":{"$ref":"#/$defs/elaboration_type"},"termination":{"additionalProperties":false,"properties":{"evidence":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array"},"measure":{"$ref":"#/$defs/elaboration_term"}},"required":["evidence","measure"],"type":"object"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["body","kind","name","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"theorem"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"proof":{"$ref":"#/$defs/elaboration_proof"},"statement":{"$ref":"#/$defs/elaboration_term"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["kind","name","parameters","proof","statement"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"artifact"},"length":{"minimum":0,"type":"integer"},"name":{"$ref":"#/$defs/elaboration_name"},"role":{"enum":["binary","dataset","parameters","table","vocabulary"]},"schema":{"$ref":"#/$defs/elaboration_artifactSchema"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","length","name","role","schema","sha256","type"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"input":{"$ref":"#/$defs/elaboration_modelBinder"},"invariant":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"contract"},"name":{"$ref":"#/$defs/elaboration_name"},"output":{"$ref":"#/$defs/elaboration_modelBinder"},"postcondition":{"$ref":"#/$defs/elaboration_member"},"precondition":{"$ref":"#/$defs/elaboration_member"},"state":{"$ref":"#/$defs/elaboration_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"validators":{"items":{"$ref":"#/$defs/elaboration_contractValidator"},"type":"array"}},"required":["input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"descriptor":{"$ref":"#/$defs/elaboration_descriptor"},"executable":{"type":"boolean"},"input":{"$ref":"#/$defs/elaboration_modelBinder"},"kind":{"const":"realization"},"name":{"$ref":"#/$defs/elaboration_name"},"output":{"$ref":"#/$defs/elaboration_type"},"state":{"$ref":"#/$defs/elaboration_realizationState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["descriptor","input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/elaboration_claim"},"minItems":1,"type":"array"},"contract":{"$ref":"#/$defs/elaboration_modelUse"},"kind":{"const":"evidence"},"name":{"$ref":"#/$defs/elaboration_name"},"realization":{"$ref":"#/$defs/elaboration_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["claims","contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"contract":{"$ref":"#/$defs/elaboration_modelUse"},"entry":{"items":{"$ref":"#/$defs/elaboration_member"},"type":"array"},"evidence":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"type":"array"},"kind":{"const":"model"},"name":{"$ref":"#/$defs/elaboration_name"},"realization":{"$ref":"#/$defs/elaboration_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"invariant":{"$ref":"#/$defs/elaboration_logicInvariant"},"kind":{"const":"logic"},"name":{"$ref":"#/$defs/elaboration_name"},"ranking":{"$ref":"#/$defs/elaboration_member"},"relation":{"$ref":"#/$defs/elaboration_member"},"state":{"$ref":"#/$defs/elaboration_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["kind","name","relation","state"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"binding":{"$ref":"#/$defs/elaboration_ruleBinding"},"conclusion":{"$ref":"#/$defs/elaboration_term"},"executable":{"type":"boolean"},"guard":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"inference_rule"},"logic":{"$ref":"#/$defs/elaboration_modelUse"},"name":{"$ref":"#/$defs/elaboration_name"},"progress":{"$ref":"#/$defs/elaboration_member"},"soundness":{"$ref":"#/$defs/elaboration_member"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["conclusion","guard","kind","logic","name","soundness"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"candidate":{"$ref":"#/$defs/elaboration_modelBinder"},"check":{"$ref":"#/$defs/elaboration_member"},"complete":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"verifier"},"name":{"$ref":"#/$defs/elaboration_name"},"sound":{"$ref":"#/$defs/elaboration_member"},"specification":{"$ref":"#/$defs/elaboration_member"},"subject":{"$ref":"#/$defs/elaboration_modelBinder"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["candidate","check","kind","name","sound","specification","subject"],"type":"object"},{"additionalProperties":false,"properties":{"answer":{"$ref":"#/$defs/elaboration_reasoningAnswer"},"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/elaboration_reasoningClaim"},"type":"array"},"executable":{"type":"boolean"},"kind":{"const":"reasoner"},"logic":{"$ref":"#/$defs/elaboration_modelUse"},"name":{"$ref":"#/$defs/elaboration_name"},"observation":{"$ref":"#/$defs/elaboration_modelBinder"},"observe":{"$ref":"#/$defs/elaboration_term"},"rules":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"type":"array"},"strategy":{"$ref":"#/$defs/elaboration_reasoningStrategy"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"verifier":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","name","observation","rules","strategy","verifier"],"type":"object"}]},"elaboration_descriptor":{"oneOf":[{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"deterministic"}},"required":["body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"default":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"rule"},"rules":{"items":{"$ref":"#/$defs/elaboration_realizationRule"},"minItems":1,"type":"array"}},"required":["default","kind","rules"],"type":"object"},{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/elaboration_member"},"features":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"statistical"},"labels":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"},"scheme":{"const":"linear_scoring"},"weights":{"$ref":"#/$defs/elaboration_member"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/elaboration_member"}},"required":["bias","features","kind","labels","scheme","weights","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"architecture":{"const":"integer_feedforward"},"decoder":{"$ref":"#/$defs/elaboration_neuralDecoder"},"encoder":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"neural"},"layers":{"items":{"$ref":"#/$defs/elaboration_neuralLayer"},"minItems":1,"type":"array"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/elaboration_member"}},"required":["architecture","decoder","encoder","kind","layers","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"form":{"$ref":"#/$defs/elaboration_compositeForm"},"kind":{"const":"composite"}},"required":["form","kind"],"type":"object"}]},"elaboration_field":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_logicInvariant":{"additionalProperties":false,"properties":{"predicate":{"$ref":"#/$defs/elaboration_member"},"preserves":{"$ref":"#/$defs/elaboration_member"}},"required":["predicate","preserves"],"type":"object"},"elaboration_member":{"additionalProperties":false,"properties":{"module":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["name"],"type":"object"},"elaboration_modelBinder":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_modelUse":{"additionalProperties":false,"properties":{"member":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["member"],"type":"object"},"elaboration_name":{"description":"A name inside an elaboration. Besides every source spelling it admits the reserved spelling with two leading underscores, which only generated binders use; linking rejects it in every source module, and the source semantic_name excludes it.","pattern":"^(__)?[A-Za-z][A-Za-z0-9_]*(\\.(__)?[A-Za-z][A-Za-z0-9_]*)*$","type":"string"},"elaboration_neuralDecoder":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"argmax"},"labels":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"}},"required":["kind","labels"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_name"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"function"}},"required":["binder","body","kind"],"type":"object"}]},"elaboration_neuralLayer":{"oneOf":[{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/elaboration_member"},"inputs":{"minimum":1,"type":"integer"},"kind":{"const":"dense"},"outputs":{"minimum":1,"type":"integer"},"weights":{"$ref":"#/$defs/elaboration_member"}},"required":["bias","inputs","kind","outputs","weights"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"relu"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"requantize"},"maximum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"minimum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"shift":{"maximum":4096,"minimum":0,"type":"integer"}},"required":["kind","maximum","minimum","shift"],"type":"object"}]},"elaboration_parameter":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_production":{"additionalProperties":false,"properties":{"effects":{"items":{"enum":["allocation","overflow","recursion"]},"type":"array","uniqueItems":true},"targets":{"items":{"enum":["rust-core","rust-std"]},"minItems":1,"type":"array","uniqueItems":true}},"required":["effects","targets"],"type":"object"},"elaboration_proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"reflexivity"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"simplify"}},"required":["definitions","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proof"},"minItems":1,"type":"array"},"kind":{"const":"constructor"}},"required":["branches","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proofBranch"},"minItems":1,"type":"array"},"kind":{"const":"cases"},"scrutinee":{"$ref":"#/$defs/elaboration_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proofBranch"},"minItems":1,"type":"array"},"generalizing":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"induction"},"scrutinee":{"$ref":"#/$defs/elaboration_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"congruence"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"boolean_reflection"},"reflection":{"$ref":"#/$defs/elaboration_reflection"}},"required":["kind","reflection"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"law"},"name":{"$ref":"#/$defs/elaboration_name"},"premises":{"items":{"$ref":"#/$defs/elaboration_member"},"type":"array"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"apply"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"linear_arithmetic"}},"required":["kind"],"type":"object"}]},"elaboration_proofBranch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"constructor":{"$ref":"#/$defs/elaboration_name"},"proof":{"$ref":"#/$defs/elaboration_proof"}},"required":["binders","constructor","proof"],"type":"object"},"elaboration_realizationRule":{"additionalProperties":false,"properties":{"action":{"$ref":"#/$defs/elaboration_term"},"guard":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["action","guard","name"],"type":"object"},"elaboration_realizationState":{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["initial","name","type"],"type":"object"},"elaboration_reasoningAnswer":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["name","type","value"],"type":"object"},"elaboration_reasoningClaim":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"answer_correct"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"observation_invariant"},"predicate":{"$ref":"#/$defs/elaboration_member"},"preserved":{"$ref":"#/$defs/elaboration_member"}},"required":["initial","kind","predicate","preserved"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"terminates"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"}]},"elaboration_reasoningStrategy":{"oneOf":[{"additionalProperties":false,"properties":{"fuel":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"forward"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"budget":{"$ref":"#/$defs/elaboration_term"},"generator":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"generate_and_verify"}},"required":["generator","kind"],"type":"object"},{"additionalProperties":false,"properties":{"deduplicate":{"type":"boolean"},"frontier":{"$ref":"#/$defs/elaboration_term"},"fuel":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"search"},"order":{"enum":["breadth_first","depth_first"]}},"required":["kind","order"],"type":"object"}]},"elaboration_reflection":{"oneOf":[{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/elaboration_member"},"comparison":{"$ref":"#/$defs/elaboration_reflectionComparison"},"kind":{"const":"list"},"parameter":{"$ref":"#/$defs/elaboration_name"},"proposition_definition":{"$ref":"#/$defs/elaboration_member"},"values":{"$ref":"#/$defs/elaboration_name"}},"required":["boolean_definition","comparison","kind","parameter","proposition_definition","values"],"type":"object"},{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/elaboration_member"},"fields":{"items":{"$ref":"#/$defs/elaboration_reflectionField"},"minItems":1,"type":"array"},"kind":{"const":"record"},"proposition_definition":{"$ref":"#/$defs/elaboration_member"},"record":{"$ref":"#/$defs/elaboration_name"}},"required":["boolean_definition","fields","kind","proposition_definition","record"],"type":"object"}]},"elaboration_reflectionComparison":{"enum":["nat_beq","nat_blt"]},"elaboration_reflectionField":{"additionalProperties":false,"properties":{"expected":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]},"field":{"$ref":"#/$defs/elaboration_name"}},"required":["expected","field"],"type":"object"},"elaboration_ruleBinding":{"additionalProperties":false,"properties":{"candidates":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["candidates","name","type"],"type":"object"},"elaboration_term":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"var"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"nat"},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"bool"},"value":{"type":"boolean"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["int","int8","int16","int32","int64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["uint8","uint16","uint32","uint64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"string"},"value":{"type":"string"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"hex":{"pattern":"^([0-9a-f]{2})*$","type":"string"},"kind":{"const":"bytes"}},"required":["hex","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"primitive"},"operation":{"enum":["append","bit_and","bit_not","bit_or","bit_xor","checked_add","checked_convert","checked_multiply","checked_negate","checked_quotient","checked_subtract","compare_bytes","equal","format_decimal","graph_reachable","graph_successors","graph_topological","index","iterate","iterate_until","join","length","less_than","list_fold","map_contains","map_entries","map_fold","map_insert","map_keys","map_lookup","map_remove","map_size","map_values","multiply","negate","parse_decimal","quotient","remainder","set_contains","set_difference","set_elements","set_fold","set_insert","set_intersection","set_remove","set_size","set_union","shift_left","shift_right","slice","split_exact","subtract","utf8_decode","utf8_encode"]},"result":{"$ref":"#/$defs/elaboration_type"}},"required":["arguments","kind","operation","result"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"unit"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"nil"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"head":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"cons"},"tail":{"$ref":"#/$defs/elaboration_term"}},"required":["head","kind","tail"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_assignment"},"type":"array"},"kind":{"const":"record"},"type":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["fields","kind","type"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"constructor":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"constructor"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","constructor","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"class":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"instance_value"},"resolved":{"$ref":"#/$defs/elaboration_member"}},"required":["arguments","class","kind","resolved"],"type":"object"},{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"project"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["field","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"function":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"call"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"condition":{"$ref":"#/$defs/elaboration_term"},"else_value":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"if"},"then_value":{"$ref":"#/$defs/elaboration_term"}},"required":["condition","else_value","kind","then_value"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_branch"},"minItems":1,"type":"array"},"kind":{"const":"match"},"scrutinee":{"$ref":"#/$defs/elaboration_term"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"eq"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"le"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"lt"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"add"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"beq"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"ble"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"blt"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"and"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"or"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"iff"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/elaboration_term"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"not"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_parameter"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"forall"}},"required":["binder","body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"prop_and"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_parameter"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"let"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["binder","body","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"pair"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"first"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"second"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/elaboration_term"},"captures":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"lambda"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"minItems":1,"type":"array"}},"required":["body","captures","kind","parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"},"function":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"apply"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"function":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"function_ref"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"entries":{"items":{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/elaboration_term"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["key","value"],"type":"object"},"type":"array"},"key":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"map_literal"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["entries","key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"elements":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"set_literal"}},"required":["element","elements","kind"],"type":"object"},{"additionalProperties":false,"properties":{"edges":{"items":{"additionalProperties":false,"properties":{"source":{"$ref":"#/$defs/elaboration_term"},"target":{"$ref":"#/$defs/elaboration_term"}},"required":["source","target"],"type":"object"},"type":"array"},"kind":{"const":"graph_literal"},"node":{"$ref":"#/$defs/elaboration_type"},"nodes":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"}},"required":["edges","kind","node","nodes"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array","uniqueItems":true},"kind":{"const":"checked_apply"},"model":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","checks","kind","model"],"type":"object"}]},"elaboration_type":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"enum":["bool","bytes","int","int8","int16","int32","int64","nat","ordering","prop","string","type","uint8","uint16","uint32","uint64","unit"]}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"parameter"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"list"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"kind":{"const":"named"},"member":{"$ref":"#/$defs/elaboration_member"}},"required":["arguments","kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"option"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"error":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"result"},"ok":{"$ref":"#/$defs/elaboration_type"}},"required":["error","kind","ok"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/elaboration_type"},"right":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"function"},"parameters":{"items":{"$ref":"#/$defs/elaboration_type"},"minItems":1,"type":"array"},"result":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"map"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"set"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"contract_violation"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"reasoning_failure"}},"required":["kind"],"type":"object"}]},"formula":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"term"},"term":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","term"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"helper":{"enum":["all","complete","preserves","reaches","search_ok","sound","star"]},"kind":{"const":"helper"}},"required":["arguments","helper","kind"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/formula"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/formula"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"true"}},"required":["kind"],"type":"object"}]},"generatedTheorem":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"statement":{"$ref":"#/$defs/formula"},"template":{"enum":["accept_sound","conclude_accept","conclude_sound","explained_forward","explained_generate","explained_search","extend","fire_cases","next_progress","next_sound","replay_fire","replay_sound","run_invariant","search_count","search_growth","search_peak","search_step","step_count","step_none","step_some","step_trace","successors_bound","successors_free","term","try_count","try_sound","unfold","verdict_forward","verdict_generate","verdict_search","verify_sound"]},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["name","parameters","statement","template","type_parameters"],"type":"object"},"module":{"additionalProperties":false,"properties":{"core":{"$ref":"#/$defs/semanticValue"},"declarations":{"items":{"$ref":"#/$defs/declaration"},"type":"array"},"glossary":{"items":{"type":"string"},"type":"array"},"imports":{"items":{"type":"string"},"type":"array"},"lean_module":{"minLength":1,"type":"string"},"linked_ir":{"$ref":"#/$defs/semanticValue"},"name":{"minLength":1,"type":"string"},"semantic":{"$ref":"#/$defs/semanticModule"},"source":{"$ref":"#/$defs/source"},"visible_packages":{"items":{"type":"string"},"type":"array"}},"required":["declarations","glossary","imports","lean_module","linked_ir","name","source","visible_packages"],"type":"object"},"obligation":{"additionalProperties":false,"properties":{"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"role":{"minLength":1,"type":"string"},"statement":{"$ref":"#/$defs/elaboration_term"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["parameters","role","statement","theorem","type_parameters"],"type":"object"},"origin":{"additionalProperties":false,"properties":{"proof":{"$ref":"#/$defs/range"},"proof_steps":{"items":{"$ref":"#/$defs/range"},"type":"array"},"sentence":{"$ref":"#/$defs/range"},"whole":{"$ref":"#/$defs/range"}},"required":["proof_steps","sentence","whole"],"type":"object"},"range":{"additionalProperties":false,"properties":{"end":{"minimum":0,"type":"integer"},"start":{"minimum":0,"type":"integer"}},"required":["end","start"],"type":"object"},"semanticModule":{"additionalProperties":false,"properties":{"declarations":{"items":{"$ref":"#/$defs/semantic_declaration"},"minItems":1,"type":"array"},"spec":{"const":"lexlean/semantic-module/2"}},"required":["declarations","spec"],"type":"object"},"semanticValue":{"oneOf":[{"type":"boolean"},{"type":"integer"},{"type":"string"},{"items":{"$ref":"#/$defs/semanticValue"},"type":"array"},{"additionalProperties":{"$ref":"#/$defs/semanticValue"},"type":"object"}]},"semantic_artifactSchema":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"bytes"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"int_tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"utf8_lines"}},"required":["kind"],"type":"object"}]},"semantic_assignment":{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/semantic_name"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["field","value"],"type":"object"},"semantic_branch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/semantic_term"},"constructor":{"$ref":"#/$defs/semantic_member"}},"required":["binders","body","constructor"],"type":"object"},"semantic_claim":{"oneOf":[{"additionalProperties":false,"properties":{"agreements":{"minimum":0,"type":"integer"},"comparison":{"$ref":"#/$defs/semantic_member"},"comparison_sound":{"$ref":"#/$defs/semantic_member"},"dataset":{"$ref":"#/$defs/semantic_member"},"examples":{"minimum":0,"type":"integer"},"kind":{"const":"dataset_agreement"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["agreements","comparison","comparison_sound","dataset","examples","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"equivalent_to"},"reference":{"$ref":"#/$defs/semantic_modelUse"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","reference","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"preserves_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"satisfies_contract"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"}]},"semantic_compositeForm":{"oneOf":[{"additionalProperties":false,"properties":{"junctions":{"items":{"$ref":"#/$defs/semantic_compositeJunction"},"minItems":1,"type":"array"},"kind":{"const":"sequence"},"stages":{"items":{"$ref":"#/$defs/semantic_modelUse"},"minItems":2,"type":"array"}},"required":["junctions","kind","stages"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"fanout"},"left":{"$ref":"#/$defs/semantic_modelUse"},"right":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/semantic_modelUse"},"right":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"else":{"$ref":"#/$defs/semantic_modelUse"},"guard":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"branch"},"then":{"$ref":"#/$defs/semantic_modelUse"}},"required":["else","guard","kind","then"],"type":"object"},{"additionalProperties":false,"properties":{"junction":{"$ref":"#/$defs/semantic_compositeJunction"},"kind":{"const":"scan"},"stage":{"$ref":"#/$defs/semantic_modelUse"}},"required":["junction","kind","stage"],"type":"object"}]},"semantic_compositeJunction":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"unconditional"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"evidence":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"proved"}},"required":["evidence","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"checked"}},"required":["kind"],"type":"object"}]},"semantic_constructor":{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["fields","name"],"type":"object"},"semantic_contractState":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"next":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","next","type"],"type":"object"},"semantic_contractValidator":{"additionalProperties":false,"properties":{"complete":{"$ref":"#/$defs/semantic_member"},"predicate":{"enum":["invariant","postcondition","precondition"]},"sound":{"$ref":"#/$defs/semantic_member"},"validator":{"$ref":"#/$defs/semantic_member"}},"required":["predicate","sound","validator"],"type":"object"},"semantic_declaration":{"oneOf":[{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_field"},"minItems":1,"type":"array"},"kind":{"const":"structure"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_field"},"minItems":1,"type":"array"},"kind":{"const":"class"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"class":{"$ref":"#/$defs/semantic_member"},"fields":{"items":{"$ref":"#/$defs/semantic_assignment"},"minItems":1,"type":"array"},"kind":{"const":"instance"},"name":{"$ref":"#/$defs/semantic_name"},"priority":{"const":1000}},"required":["arguments","class","fields","kind","name","priority"],"type":"object"},{"additionalProperties":false,"properties":{"constructors":{"items":{"$ref":"#/$defs/semantic_constructor"},"minItems":1,"type":"array"},"kind":{"const":"inductive"},"mutual":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["constructors","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/semantic_term"},"executable":{"type":"boolean"},"kind":{"const":"definition"},"mutual":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"production":{"$ref":"#/$defs/semantic_production"},"recursive_argument":{"$ref":"#/$defs/semantic_name"},"result":{"$ref":"#/$defs/semantic_type"},"termination":{"additionalProperties":false,"properties":{"evidence":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array"},"measure":{"$ref":"#/$defs/semantic_term"}},"required":["evidence","measure"],"type":"object"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["body","kind","name","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"theorem"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"proof":{"$ref":"#/$defs/semantic_proof"},"statement":{"$ref":"#/$defs/semantic_term"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["kind","name","parameters","proof","statement"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"artifact"},"length":{"minimum":0,"type":"integer"},"name":{"$ref":"#/$defs/semantic_name"},"role":{"enum":["binary","dataset","parameters","table","vocabulary"]},"schema":{"$ref":"#/$defs/semantic_artifactSchema"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["kind","length","name","role","schema","sha256","type"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"input":{"$ref":"#/$defs/semantic_modelBinder"},"invariant":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"contract"},"name":{"$ref":"#/$defs/semantic_name"},"output":{"$ref":"#/$defs/semantic_modelBinder"},"postcondition":{"$ref":"#/$defs/semantic_member"},"precondition":{"$ref":"#/$defs/semantic_member"},"state":{"$ref":"#/$defs/semantic_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"validators":{"items":{"$ref":"#/$defs/semantic_contractValidator"},"type":"array"}},"required":["input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"descriptor":{"$ref":"#/$defs/semantic_descriptor"},"executable":{"type":"boolean"},"input":{"$ref":"#/$defs/semantic_modelBinder"},"kind":{"const":"realization"},"name":{"$ref":"#/$defs/semantic_name"},"output":{"$ref":"#/$defs/semantic_type"},"state":{"$ref":"#/$defs/semantic_realizationState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["descriptor","input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/semantic_claim"},"minItems":1,"type":"array"},"contract":{"$ref":"#/$defs/semantic_modelUse"},"kind":{"const":"evidence"},"name":{"$ref":"#/$defs/semantic_name"},"realization":{"$ref":"#/$defs/semantic_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["claims","contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"contract":{"$ref":"#/$defs/semantic_modelUse"},"entry":{"items":{"$ref":"#/$defs/semantic_member"},"type":"array"},"evidence":{"items":{"$ref":"#/$defs/semantic_modelUse"},"type":"array"},"kind":{"const":"model"},"name":{"$ref":"#/$defs/semantic_name"},"realization":{"$ref":"#/$defs/semantic_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"invariant":{"$ref":"#/$defs/semantic_logicInvariant"},"kind":{"const":"logic"},"name":{"$ref":"#/$defs/semantic_name"},"ranking":{"$ref":"#/$defs/semantic_member"},"relation":{"$ref":"#/$defs/semantic_member"},"state":{"$ref":"#/$defs/semantic_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["kind","name","relation","state"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"binding":{"$ref":"#/$defs/semantic_ruleBinding"},"conclusion":{"$ref":"#/$defs/semantic_term"},"executable":{"type":"boolean"},"guard":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"inference_rule"},"logic":{"$ref":"#/$defs/semantic_modelUse"},"name":{"$ref":"#/$defs/semantic_name"},"progress":{"$ref":"#/$defs/semantic_member"},"soundness":{"$ref":"#/$defs/semantic_member"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["conclusion","guard","kind","logic","name","soundness"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"candidate":{"$ref":"#/$defs/semantic_modelBinder"},"check":{"$ref":"#/$defs/semantic_member"},"complete":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"verifier"},"name":{"$ref":"#/$defs/semantic_name"},"sound":{"$ref":"#/$defs/semantic_member"},"specification":{"$ref":"#/$defs/semantic_member"},"subject":{"$ref":"#/$defs/semantic_modelBinder"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["candidate","check","kind","name","sound","specification","subject"],"type":"object"},{"additionalProperties":false,"properties":{"answer":{"$ref":"#/$defs/semantic_reasoningAnswer"},"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/semantic_reasoningClaim"},"type":"array"},"executable":{"type":"boolean"},"kind":{"const":"reasoner"},"logic":{"$ref":"#/$defs/semantic_modelUse"},"name":{"$ref":"#/$defs/semantic_name"},"observation":{"$ref":"#/$defs/semantic_modelBinder"},"observe":{"$ref":"#/$defs/semantic_term"},"rules":{"items":{"$ref":"#/$defs/semantic_modelUse"},"type":"array"},"strategy":{"$ref":"#/$defs/semantic_reasoningStrategy"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"verifier":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","name","observation","rules","strategy","verifier"],"type":"object"}]},"semantic_descriptor":{"oneOf":[{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"deterministic"}},"required":["body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"default":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"rule"},"rules":{"items":{"$ref":"#/$defs/semantic_realizationRule"},"minItems":1,"type":"array"}},"required":["default","kind","rules"],"type":"object"},{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/semantic_member"},"features":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"statistical"},"labels":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"},"scheme":{"const":"linear_scoring"},"weights":{"$ref":"#/$defs/semantic_member"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/semantic_member"}},"required":["bias","features","kind","labels","scheme","weights","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"architecture":{"const":"integer_feedforward"},"decoder":{"$ref":"#/$defs/semantic_neuralDecoder"},"encoder":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"neural"},"layers":{"items":{"$ref":"#/$defs/semantic_neuralLayer"},"minItems":1,"type":"array"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/semantic_member"}},"required":["architecture","decoder","encoder","kind","layers","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"form":{"$ref":"#/$defs/semantic_compositeForm"},"kind":{"const":"composite"}},"required":["form","kind"],"type":"object"}]},"semantic_field":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_logicInvariant":{"additionalProperties":false,"properties":{"predicate":{"$ref":"#/$defs/semantic_member"},"preserves":{"$ref":"#/$defs/semantic_member"}},"required":["predicate","preserves"],"type":"object"},"semantic_member":{"additionalProperties":false,"properties":{"module":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["name"],"type":"object"},"semantic_modelBinder":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_modelUse":{"additionalProperties":false,"properties":{"member":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["member"],"type":"object"},"semantic_name":{"pattern":"^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)*$","type":"string"},"semantic_neuralDecoder":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"argmax"},"labels":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"}},"required":["kind","labels"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_name"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"function"}},"required":["binder","body","kind"],"type":"object"}]},"semantic_neuralLayer":{"oneOf":[{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/semantic_member"},"inputs":{"minimum":1,"type":"integer"},"kind":{"const":"dense"},"outputs":{"minimum":1,"type":"integer"},"weights":{"$ref":"#/$defs/semantic_member"}},"required":["bias","inputs","kind","outputs","weights"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"relu"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"requantize"},"maximum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"minimum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"shift":{"maximum":4096,"minimum":0,"type":"integer"}},"required":["kind","maximum","minimum","shift"],"type":"object"}]},"semantic_parameter":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_production":{"additionalProperties":false,"properties":{"effects":{"items":{"enum":["allocation","overflow","recursion"]},"type":"array","uniqueItems":true},"targets":{"items":{"enum":["rust-core","rust-std"]},"minItems":1,"type":"array","uniqueItems":true}},"required":["effects","targets"],"type":"object"},"semantic_proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"reflexivity"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"simplify"}},"required":["definitions","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proof"},"minItems":1,"type":"array"},"kind":{"const":"constructor"}},"required":["branches","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proofBranch"},"minItems":1,"type":"array"},"kind":{"const":"cases"},"scrutinee":{"$ref":"#/$defs/semantic_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proofBranch"},"minItems":1,"type":"array"},"generalizing":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"induction"},"scrutinee":{"$ref":"#/$defs/semantic_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"congruence"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"boolean_reflection"},"reflection":{"$ref":"#/$defs/semantic_reflection"}},"required":["kind","reflection"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"law"},"name":{"$ref":"#/$defs/semantic_name"},"premises":{"items":{"$ref":"#/$defs/semantic_member"},"type":"array"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"apply"},"theorem":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"linear_arithmetic"}},"required":["kind"],"type":"object"}]},"semantic_proofBranch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"constructor":{"$ref":"#/$defs/semantic_name"},"proof":{"$ref":"#/$defs/semantic_proof"}},"required":["binders","constructor","proof"],"type":"object"},"semantic_realizationRule":{"additionalProperties":false,"properties":{"action":{"$ref":"#/$defs/semantic_term"},"guard":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["action","guard","name"],"type":"object"},"semantic_realizationState":{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["initial","name","type"],"type":"object"},"semantic_reasoningAnswer":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["name","type","value"],"type":"object"},"semantic_reasoningClaim":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"answer_correct"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"observation_invariant"},"predicate":{"$ref":"#/$defs/semantic_member"},"preserved":{"$ref":"#/$defs/semantic_member"}},"required":["initial","kind","predicate","preserved"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"terminates"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"}]},"semantic_reasoningStrategy":{"oneOf":[{"additionalProperties":false,"properties":{"fuel":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"forward"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"budget":{"$ref":"#/$defs/semantic_term"},"generator":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"generate_and_verify"}},"required":["generator","kind"],"type":"object"},{"additionalProperties":false,"properties":{"deduplicate":{"type":"boolean"},"frontier":{"$ref":"#/$defs/semantic_term"},"fuel":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"search"},"order":{"enum":["breadth_first","depth_first"]}},"required":["kind","order"],"type":"object"}]},"semantic_reflection":{"oneOf":[{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/semantic_member"},"comparison":{"$ref":"#/$defs/semantic_reflectionComparison"},"kind":{"const":"list"},"parameter":{"$ref":"#/$defs/semantic_name"},"proposition_definition":{"$ref":"#/$defs/semantic_member"},"values":{"$ref":"#/$defs/semantic_name"}},"required":["boolean_definition","comparison","kind","parameter","proposition_definition","values"],"type":"object"},{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/semantic_member"},"fields":{"items":{"$ref":"#/$defs/semantic_reflectionField"},"minItems":1,"type":"array"},"kind":{"const":"record"},"proposition_definition":{"$ref":"#/$defs/semantic_member"},"record":{"$ref":"#/$defs/semantic_name"}},"required":["boolean_definition","fields","kind","proposition_definition","record"],"type":"object"}]},"semantic_reflectionComparison":{"enum":["nat_beq","nat_blt"]},"semantic_reflectionField":{"additionalProperties":false,"properties":{"expected":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]},"field":{"$ref":"#/$defs/semantic_name"}},"required":["expected","field"],"type":"object"},"semantic_ruleBinding":{"additionalProperties":false,"properties":{"candidates":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["candidates","name","type"],"type":"object"},"semantic_term":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"var"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"nat"},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"bool"},"value":{"type":"boolean"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["int","int8","int16","int32","int64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["uint8","uint16","uint32","uint64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"string"},"value":{"type":"string"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"hex":{"pattern":"^([0-9a-f]{2})*$","type":"string"},"kind":{"const":"bytes"}},"required":["hex","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"primitive"},"operation":{"enum":["append","bit_and","bit_not","bit_or","bit_xor","checked_add","checked_convert","checked_multiply","checked_negate","checked_quotient","checked_subtract","compare_bytes","equal","format_decimal","graph_reachable","graph_successors","graph_topological","index","iterate","iterate_until","join","length","less_than","list_fold","map_contains","map_entries","map_fold","map_insert","map_keys","map_lookup","map_remove","map_size","map_values","multiply","negate","parse_decimal","quotient","remainder","set_contains","set_difference","set_elements","set_fold","set_insert","set_intersection","set_remove","set_size","set_union","shift_left","shift_right","slice","split_exact","subtract","utf8_decode","utf8_encode"]},"result":{"$ref":"#/$defs/semantic_type"}},"required":["arguments","kind","operation","result"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"unit"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"nil"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"head":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"cons"},"tail":{"$ref":"#/$defs/semantic_term"}},"required":["head","kind","tail"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_assignment"},"type":"array"},"kind":{"const":"record"},"type":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["fields","kind","type"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"constructor":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"constructor"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","constructor","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"class":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"instance_value"},"resolved":{"$ref":"#/$defs/semantic_member"}},"required":["arguments","class","kind","resolved"],"type":"object"},{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/semantic_name"},"kind":{"const":"project"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["field","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"function":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"call"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"condition":{"$ref":"#/$defs/semantic_term"},"else_value":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"if"},"then_value":{"$ref":"#/$defs/semantic_term"}},"required":["condition","else_value","kind","then_value"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_branch"},"minItems":1,"type":"array"},"kind":{"const":"match"},"scrutinee":{"$ref":"#/$defs/semantic_term"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"eq"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"le"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"lt"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"add"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"beq"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"ble"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"blt"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"and"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"or"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"iff"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/semantic_term"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"not"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_parameter"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"forall"}},"required":["binder","body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"prop_and"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_parameter"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"let"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["binder","body","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"pair"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"first"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"second"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/semantic_term"},"captures":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"lambda"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"minItems":1,"type":"array"}},"required":["body","captures","kind","parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"},"function":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"apply"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"function":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"function_ref"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"entries":{"items":{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/semantic_term"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["key","value"],"type":"object"},"type":"array"},"key":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"map_literal"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["entries","key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"elements":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"set_literal"}},"required":["element","elements","kind"],"type":"object"},{"additionalProperties":false,"properties":{"edges":{"items":{"additionalProperties":false,"properties":{"source":{"$ref":"#/$defs/semantic_term"},"target":{"$ref":"#/$defs/semantic_term"}},"required":["source","target"],"type":"object"},"type":"array"},"kind":{"const":"graph_literal"},"node":{"$ref":"#/$defs/semantic_type"},"nodes":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"}},"required":["edges","kind","node","nodes"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array","uniqueItems":true},"kind":{"const":"checked_apply"},"model":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","checks","kind","model"],"type":"object"}]},"semantic_type":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"enum":["bool","bytes","int","int8","int16","int32","int64","nat","ordering","prop","string","type","uint8","uint16","uint32","uint64","unit"]}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"parameter"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"list"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"kind":{"const":"named"},"member":{"$ref":"#/$defs/semantic_member"}},"required":["arguments","kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"option"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"error":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"result"},"ok":{"$ref":"#/$defs/semantic_type"}},"required":["error","kind","ok"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/semantic_type"},"right":{"$ref":"#/$defs/semantic_type"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"function"},"parameters":{"items":{"$ref":"#/$defs/semantic_type"},"minItems":1,"type":"array"},"result":{"$ref":"#/$defs/semantic_type"}},"required":["kind","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"map"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"set"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"contract_violation"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"reasoning_failure"}},"required":["kind"],"type":"object"}]},"source":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"$ref":"#/$defs/digest"}},"required":["path","sha256"],"type":"object"}},"$id":"https://github.com/afflom/lexlean/schemas/semantic-snapshot-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"compiler_semantics_id":{"$ref":"#/$defs/digest"},"language":{"const":"1.2"},"lexicon_closure":{"$ref":"#/$defs/semanticValue"},"modules":{"items":{"$ref":"#/$defs/module"},"type":"array"},"semantic_id":{"$ref":"#/$defs/digest"},"source_id":{"$ref":"#/$defs/digest"},"spec":{"const":"lexlean/semantic-snapshot/2"}},"required":["compiler_semantics_id","language","lexicon_closure","modules","semantic_id","source_id","spec"],"title":"LexLean language-1.2 semantic snapshot","type":"object"} +{"$defs":{"axiomPolicy":{"additionalProperties":false,"properties":{"axioms":{"items":{"type":"string"},"type":"array","uniqueItems":true},"kind":{"enum":["allow","exact","none"]}},"required":["axioms","kind"],"type":"object"},"crossCheck":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"theorem"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["kind","theorem","type_arguments"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"}]},"statement":{"oneOf":[{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"helper":{"minLength":1,"type":"string"},"kind":{"const":"helper"}},"required":["arguments","helper","kind"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["artifact","element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"lines"}},"required":["artifact","kind"],"type":"object"},{"additionalProperties":false,"properties":{"artifact":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"bytes"}},"required":["artifact","kind"],"type":"object"}]},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["name","proof","statement","type_parameters"],"type":"object"},"declaration":{"additionalProperties":false,"properties":{"alpha_id":{"$ref":"#/$defs/digest"},"axiom_policy":{"$ref":"#/$defs/axiomPolicy"},"elaboration":{"$ref":"#/$defs/elaboration"},"kind":{"enum":["abbrev","artifact","class","constructor","contract","corollary","definition","evidence","inductive","inference_rule","instance","lemma","logic","model","predicatedefinition","realization","reasoner","recursor","structure","termdefinition","theorem","typedefinition","verifier"]},"lean_name":{"minLength":1,"type":"string"},"linked_ir":{"$ref":"#/$defs/semanticValue"},"logical_id":{"minLength":1,"type":"string"},"origin":{"$ref":"#/$defs/origin"}},"required":["axiom_policy","kind","lean_name","linked_ir","logical_id"],"type":"object"},"digest":{"pattern":"^[0-9a-f]{64}$","type":"string"},"elaboration":{"additionalProperties":false,"properties":{"alpha_ids":{"additionalProperties":{"$ref":"#/$defs/digest"},"type":"object"},"cross_checks":{"items":{"$ref":"#/$defs/crossCheck"},"type":"array"},"declarations":{"items":{"$ref":"#/$defs/elaboration_declaration"},"type":"array"},"obligations":{"items":{"$ref":"#/$defs/obligation"},"type":"array"},"required_checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array"},"theorems":{"items":{"$ref":"#/$defs/generatedTheorem"},"type":"array"}},"required":["alpha_ids","cross_checks","declarations","obligations","required_checks"],"type":"object"},"elaboration_artifactSchema":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"bytes"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"int_tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"utf8_lines"}},"required":["kind"],"type":"object"}]},"elaboration_assignment":{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/elaboration_name"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["field","value"],"type":"object"},"elaboration_branch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/elaboration_term"},"constructor":{"$ref":"#/$defs/elaboration_member"}},"required":["binders","body","constructor"],"type":"object"},"elaboration_claim":{"oneOf":[{"additionalProperties":false,"properties":{"agreements":{"minimum":0,"type":"integer"},"comparison":{"$ref":"#/$defs/elaboration_member"},"comparison_sound":{"$ref":"#/$defs/elaboration_member"},"dataset":{"$ref":"#/$defs/elaboration_member"},"examples":{"minimum":0,"type":"integer"},"kind":{"const":"dataset_agreement"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["agreements","comparison","comparison_sound","dataset","examples","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"equivalent_to"},"reference":{"$ref":"#/$defs/elaboration_modelUse"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","reference","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"preserves_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"satisfies_contract"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"}]},"elaboration_compositeForm":{"oneOf":[{"additionalProperties":false,"properties":{"junctions":{"items":{"$ref":"#/$defs/elaboration_compositeJunction"},"minItems":1,"type":"array"},"kind":{"const":"sequence"},"stages":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"minItems":2,"type":"array"}},"required":["junctions","kind","stages"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"fanout"},"left":{"$ref":"#/$defs/elaboration_modelUse"},"right":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/elaboration_modelUse"},"right":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"else":{"$ref":"#/$defs/elaboration_modelUse"},"guard":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"branch"},"then":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["else","guard","kind","then"],"type":"object"},{"additionalProperties":false,"properties":{"junction":{"$ref":"#/$defs/elaboration_compositeJunction"},"kind":{"const":"scan"},"stage":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["junction","kind","stage"],"type":"object"}]},"elaboration_compositeJunction":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"unconditional"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"evidence":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"proved"}},"required":["evidence","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"checked"}},"required":["kind"],"type":"object"}]},"elaboration_constructor":{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["fields","name"],"type":"object"},"elaboration_contractState":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"next":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","next","type"],"type":"object"},"elaboration_contractValidator":{"additionalProperties":false,"properties":{"complete":{"$ref":"#/$defs/elaboration_member"},"predicate":{"enum":["invariant","postcondition","precondition"]},"sound":{"$ref":"#/$defs/elaboration_member"},"validator":{"$ref":"#/$defs/elaboration_member"}},"required":["predicate","sound","validator"],"type":"object"},"elaboration_declaration":{"oneOf":[{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_field"},"minItems":1,"type":"array"},"kind":{"const":"structure"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_field"},"minItems":1,"type":"array"},"kind":{"const":"class"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"class":{"$ref":"#/$defs/elaboration_member"},"fields":{"items":{"$ref":"#/$defs/elaboration_assignment"},"minItems":1,"type":"array"},"kind":{"const":"instance"},"name":{"$ref":"#/$defs/elaboration_name"},"priority":{"const":1000}},"required":["arguments","class","fields","kind","name","priority"],"type":"object"},{"additionalProperties":false,"properties":{"constructors":{"items":{"$ref":"#/$defs/elaboration_constructor"},"minItems":1,"type":"array"},"kind":{"const":"inductive"},"mutual":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["constructors","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/elaboration_term"},"executable":{"type":"boolean"},"kind":{"const":"definition"},"mutual":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"production":{"$ref":"#/$defs/elaboration_production"},"recursive_argument":{"$ref":"#/$defs/elaboration_name"},"result":{"$ref":"#/$defs/elaboration_type"},"termination":{"additionalProperties":false,"properties":{"evidence":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array"},"measure":{"$ref":"#/$defs/elaboration_term"}},"required":["evidence","measure"],"type":"object"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["body","kind","name","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"theorem"},"name":{"$ref":"#/$defs/elaboration_name"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"proof":{"$ref":"#/$defs/elaboration_proof"},"statement":{"$ref":"#/$defs/elaboration_term"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["kind","name","parameters","proof","statement"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"artifact"},"length":{"minimum":0,"type":"integer"},"name":{"$ref":"#/$defs/elaboration_name"},"role":{"enum":["binary","dataset","parameters","table","vocabulary"]},"schema":{"$ref":"#/$defs/elaboration_artifactSchema"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","length","name","role","schema","sha256","type"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"input":{"$ref":"#/$defs/elaboration_modelBinder"},"invariant":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"contract"},"name":{"$ref":"#/$defs/elaboration_name"},"output":{"$ref":"#/$defs/elaboration_modelBinder"},"postcondition":{"$ref":"#/$defs/elaboration_member"},"precondition":{"$ref":"#/$defs/elaboration_member"},"state":{"$ref":"#/$defs/elaboration_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"validators":{"items":{"$ref":"#/$defs/elaboration_contractValidator"},"type":"array"}},"required":["input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"descriptor":{"$ref":"#/$defs/elaboration_descriptor"},"executable":{"type":"boolean"},"input":{"$ref":"#/$defs/elaboration_modelBinder"},"kind":{"const":"realization"},"name":{"$ref":"#/$defs/elaboration_name"},"output":{"$ref":"#/$defs/elaboration_type"},"state":{"$ref":"#/$defs/elaboration_realizationState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["descriptor","input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/elaboration_claim"},"minItems":1,"type":"array"},"contract":{"$ref":"#/$defs/elaboration_modelUse"},"kind":{"const":"evidence"},"name":{"$ref":"#/$defs/elaboration_name"},"realization":{"$ref":"#/$defs/elaboration_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["claims","contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"contract":{"$ref":"#/$defs/elaboration_modelUse"},"entry":{"items":{"$ref":"#/$defs/elaboration_member"},"type":"array"},"evidence":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"type":"array"},"kind":{"const":"model"},"name":{"$ref":"#/$defs/elaboration_name"},"realization":{"$ref":"#/$defs/elaboration_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"invariant":{"$ref":"#/$defs/elaboration_logicInvariant"},"kind":{"const":"logic"},"name":{"$ref":"#/$defs/elaboration_name"},"ranking":{"$ref":"#/$defs/elaboration_member"},"relation":{"$ref":"#/$defs/elaboration_member"},"state":{"$ref":"#/$defs/elaboration_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["kind","name","relation","state"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"binding":{"$ref":"#/$defs/elaboration_ruleBinding"},"conclusion":{"$ref":"#/$defs/elaboration_term"},"executable":{"type":"boolean"},"guard":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"inference_rule"},"logic":{"$ref":"#/$defs/elaboration_modelUse"},"name":{"$ref":"#/$defs/elaboration_name"},"progress":{"$ref":"#/$defs/elaboration_member"},"soundness":{"$ref":"#/$defs/elaboration_member"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["conclusion","guard","kind","logic","name","soundness"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"candidate":{"$ref":"#/$defs/elaboration_modelBinder"},"check":{"$ref":"#/$defs/elaboration_member"},"complete":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"verifier"},"name":{"$ref":"#/$defs/elaboration_name"},"sound":{"$ref":"#/$defs/elaboration_member"},"specification":{"$ref":"#/$defs/elaboration_member"},"subject":{"$ref":"#/$defs/elaboration_modelBinder"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true}},"required":["candidate","check","kind","name","sound","specification","subject"],"type":"object"},{"additionalProperties":false,"properties":{"answer":{"$ref":"#/$defs/elaboration_reasoningAnswer"},"axioms":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/elaboration_reasoningClaim"},"type":"array"},"executable":{"type":"boolean"},"kind":{"const":"reasoner"},"logic":{"$ref":"#/$defs/elaboration_modelUse"},"name":{"$ref":"#/$defs/elaboration_name"},"observation":{"$ref":"#/$defs/elaboration_modelBinder"},"observe":{"$ref":"#/$defs/elaboration_term"},"rules":{"items":{"$ref":"#/$defs/elaboration_modelUse"},"type":"array"},"strategy":{"$ref":"#/$defs/elaboration_reasoningStrategy"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"verifier":{"$ref":"#/$defs/elaboration_modelUse"}},"required":["kind","name","observation","rules","strategy","verifier"],"type":"object"}]},"elaboration_descriptor":{"oneOf":[{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"deterministic"}},"required":["body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"default":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"rule"},"rules":{"items":{"$ref":"#/$defs/elaboration_realizationRule"},"minItems":1,"type":"array"}},"required":["default","kind","rules"],"type":"object"},{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/elaboration_member"},"features":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"statistical"},"labels":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"},"scheme":{"const":"linear_scoring"},"weights":{"$ref":"#/$defs/elaboration_member"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/elaboration_member"}},"required":["bias","features","kind","labels","scheme","weights","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"architecture":{"const":"integer_feedforward"},"decoder":{"$ref":"#/$defs/elaboration_neuralDecoder"},"encoder":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"neural"},"layers":{"items":{"$ref":"#/$defs/elaboration_neuralLayer"},"minItems":1,"type":"array"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/elaboration_member"}},"required":["architecture","decoder","encoder","kind","layers","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"form":{"$ref":"#/$defs/elaboration_compositeForm"},"kind":{"const":"composite"}},"required":["form","kind"],"type":"object"}]},"elaboration_field":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_logicInvariant":{"additionalProperties":false,"properties":{"predicate":{"$ref":"#/$defs/elaboration_member"},"preserves":{"$ref":"#/$defs/elaboration_member"}},"required":["predicate","preserves"],"type":"object"},"elaboration_member":{"additionalProperties":false,"properties":{"module":{"$ref":"#/$defs/elaboration_name"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["name"],"type":"object"},"elaboration_modelBinder":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_modelUse":{"additionalProperties":false,"properties":{"member":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["member"],"type":"object"},"elaboration_name":{"description":"A name inside an elaboration. Besides every source spelling it admits the reserved spelling with two leading underscores, which only generated binders use; linking rejects it in every source module, and the source semantic_name excludes it.","pattern":"^(__)?[A-Za-z][A-Za-z0-9_]*(\\.(__)?[A-Za-z][A-Za-z0-9_]*)*$","type":"string"},"elaboration_neuralDecoder":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"argmax"},"labels":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"}},"required":["kind","labels"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_name"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"function"}},"required":["binder","body","kind"],"type":"object"}]},"elaboration_neuralLayer":{"oneOf":[{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/elaboration_member"},"inputs":{"minimum":1,"type":"integer"},"kind":{"const":"dense"},"outputs":{"minimum":1,"type":"integer"},"weights":{"$ref":"#/$defs/elaboration_member"}},"required":["bias","inputs","kind","outputs","weights"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"relu"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"requantize"},"maximum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"minimum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"shift":{"maximum":4096,"minimum":0,"type":"integer"}},"required":["kind","maximum","minimum","shift"],"type":"object"}]},"elaboration_parameter":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["name","type"],"type":"object"},"elaboration_production":{"additionalProperties":false,"properties":{"effects":{"items":{"enum":["allocation","overflow","recursion"]},"type":"array","uniqueItems":true},"targets":{"items":{"enum":["rust-core","rust-std"]},"minItems":1,"type":"array","uniqueItems":true}},"required":["effects","targets"],"type":"object"},"elaboration_proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"reflexivity"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"simplify"}},"required":["definitions","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proof"},"minItems":1,"type":"array"},"kind":{"const":"constructor"}},"required":["branches","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proofBranch"},"minItems":1,"type":"array"},"kind":{"const":"cases"},"scrutinee":{"$ref":"#/$defs/elaboration_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_proofBranch"},"minItems":1,"type":"array"},"generalizing":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"induction"},"scrutinee":{"$ref":"#/$defs/elaboration_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"congruence"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"boolean_reflection"},"reflection":{"$ref":"#/$defs/elaboration_reflection"}},"required":["kind","reflection"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"law"},"name":{"$ref":"#/$defs/elaboration_name"},"premises":{"items":{"$ref":"#/$defs/elaboration_member"},"type":"array"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"apply"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/elaboration_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"linear_arithmetic"}},"required":["kind"],"type":"object"}]},"elaboration_proofBranch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"constructor":{"$ref":"#/$defs/elaboration_name"},"proof":{"$ref":"#/$defs/elaboration_proof"}},"required":["binders","constructor","proof"],"type":"object"},"elaboration_realizationRule":{"additionalProperties":false,"properties":{"action":{"$ref":"#/$defs/elaboration_term"},"guard":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["action","guard","name"],"type":"object"},"elaboration_realizationState":{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["initial","name","type"],"type":"object"},"elaboration_reasoningAnswer":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["name","type","value"],"type":"object"},"elaboration_reasoningClaim":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"answer_correct"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"observation_invariant"},"predicate":{"$ref":"#/$defs/elaboration_member"},"preserved":{"$ref":"#/$defs/elaboration_member"}},"required":["initial","kind","predicate","preserved"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"terminates"},"theorem":{"$ref":"#/$defs/elaboration_member"}},"required":["kind","theorem"],"type":"object"}]},"elaboration_reasoningStrategy":{"oneOf":[{"additionalProperties":false,"properties":{"fuel":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"forward"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"budget":{"$ref":"#/$defs/elaboration_term"},"generator":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"generate_and_verify"}},"required":["generator","kind"],"type":"object"},{"additionalProperties":false,"properties":{"deduplicate":{"type":"boolean"},"frontier":{"$ref":"#/$defs/elaboration_term"},"fuel":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"search"},"order":{"enum":["breadth_first","depth_first"]}},"required":["kind","order"],"type":"object"}]},"elaboration_reflection":{"oneOf":[{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/elaboration_member"},"comparison":{"$ref":"#/$defs/elaboration_reflectionComparison"},"kind":{"const":"list"},"parameter":{"$ref":"#/$defs/elaboration_name"},"proposition_definition":{"$ref":"#/$defs/elaboration_member"},"values":{"$ref":"#/$defs/elaboration_name"}},"required":["boolean_definition","comparison","kind","parameter","proposition_definition","values"],"type":"object"},{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/elaboration_member"},"fields":{"items":{"$ref":"#/$defs/elaboration_reflectionField"},"minItems":1,"type":"array"},"kind":{"const":"record"},"proposition_definition":{"$ref":"#/$defs/elaboration_member"},"record":{"$ref":"#/$defs/elaboration_name"}},"required":["boolean_definition","fields","kind","proposition_definition","record"],"type":"object"}]},"elaboration_reflectionComparison":{"enum":["nat_beq","nat_blt"]},"elaboration_reflectionField":{"additionalProperties":false,"properties":{"expected":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]},"field":{"$ref":"#/$defs/elaboration_name"}},"required":["expected","field"],"type":"object"},"elaboration_ruleBinding":{"additionalProperties":false,"properties":{"candidates":{"$ref":"#/$defs/elaboration_term"},"name":{"$ref":"#/$defs/elaboration_name"},"type":{"$ref":"#/$defs/elaboration_type"}},"required":["candidates","name","type"],"type":"object"},"elaboration_term":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"var"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"nat"},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"bool"},"value":{"type":"boolean"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["int","int8","int16","int32","int64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["uint8","uint16","uint32","uint64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"string"},"value":{"type":"string"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"hex":{"pattern":"^([0-9a-f]{2})*$","type":"string"},"kind":{"const":"bytes"}},"required":["hex","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"primitive"},"operation":{"enum":["append","bit_and","bit_not","bit_or","bit_xor","checked_add","checked_convert","checked_multiply","checked_negate","checked_quotient","checked_subtract","compare_bytes","equal","format_decimal","graph_reachable","graph_successors","graph_topological","index","iterate","iterate_until","join","length","less_than","list_fold","map_contains","map_entries","map_fold","map_insert","map_keys","map_lookup","map_remove","map_size","map_values","multiply","negate","parse_decimal","quotient","remainder","set_contains","set_difference","set_elements","set_fold","set_insert","set_intersection","set_remove","set_size","set_union","shift_left","shift_right","slice","split_exact","subtract","utf8_decode","utf8_encode"]},"result":{"$ref":"#/$defs/elaboration_type"}},"required":["arguments","kind","operation","result"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"unit"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"nil"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"head":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"cons"},"tail":{"$ref":"#/$defs/elaboration_term"}},"required":["head","kind","tail"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/elaboration_assignment"},"type":"array"},"kind":{"const":"record"},"type":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["fields","kind","type"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"constructor":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"constructor"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","constructor","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"class":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"instance_value"},"resolved":{"$ref":"#/$defs/elaboration_member"}},"required":["arguments","class","kind","resolved"],"type":"object"},{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/elaboration_name"},"kind":{"const":"project"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["field","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"function":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"call"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"condition":{"$ref":"#/$defs/elaboration_term"},"else_value":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"if"},"then_value":{"$ref":"#/$defs/elaboration_term"}},"required":["condition","else_value","kind","then_value"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/elaboration_branch"},"minItems":1,"type":"array"},"kind":{"const":"match"},"scrutinee":{"$ref":"#/$defs/elaboration_term"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"eq"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"le"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"lt"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"add"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"beq"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"ble"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"blt"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"and"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"or"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"iff"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/elaboration_term"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"not"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_parameter"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"forall"}},"required":["binder","body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"prop_and"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/elaboration_parameter"},"body":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"let"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["binder","body","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"pair"},"left":{"$ref":"#/$defs/elaboration_term"},"right":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"first"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"second"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/elaboration_term"},"captures":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array","uniqueItems":true},"kind":{"const":"lambda"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"minItems":1,"type":"array"}},"required":["body","captures","kind","parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"minItems":1,"type":"array"},"function":{"$ref":"#/$defs/elaboration_term"},"kind":{"const":"apply"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"function":{"$ref":"#/$defs/elaboration_member"},"kind":{"const":"function_ref"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"entries":{"items":{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/elaboration_term"},"value":{"$ref":"#/$defs/elaboration_term"}},"required":["key","value"],"type":"object"},"type":"array"},"key":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"map_literal"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["entries","key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"elements":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"kind":{"const":"set_literal"}},"required":["element","elements","kind"],"type":"object"},{"additionalProperties":false,"properties":{"edges":{"items":{"additionalProperties":false,"properties":{"source":{"$ref":"#/$defs/elaboration_term"},"target":{"$ref":"#/$defs/elaboration_term"}},"required":["source","target"],"type":"object"},"type":"array"},"kind":{"const":"graph_literal"},"node":{"$ref":"#/$defs/elaboration_type"},"nodes":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"}},"required":["edges","kind","node","nodes"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array","uniqueItems":true},"kind":{"const":"checked_apply"},"model":{"$ref":"#/$defs/elaboration_member"},"type_arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"}},"required":["arguments","checks","kind","model"],"type":"object"}]},"elaboration_type":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"enum":["bool","bytes","int","int8","int16","int32","int64","nat","ordering","prop","string","type","uint8","uint16","uint32","uint64","unit"]}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"parameter"},"name":{"$ref":"#/$defs/elaboration_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"list"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_type"},"type":"array"},"kind":{"const":"named"},"member":{"$ref":"#/$defs/elaboration_member"}},"required":["arguments","kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"option"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"error":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"result"},"ok":{"$ref":"#/$defs/elaboration_type"}},"required":["error","kind","ok"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/elaboration_type"},"right":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"function"},"parameters":{"items":{"$ref":"#/$defs/elaboration_type"},"minItems":1,"type":"array"},"result":{"$ref":"#/$defs/elaboration_type"}},"required":["kind","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"map"},"value":{"$ref":"#/$defs/elaboration_type"}},"required":["key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/elaboration_type"},"kind":{"const":"set"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"contract_violation"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"reasoning_failure"}},"required":["kind"],"type":"object"}]},"formula":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"term"},"term":{"$ref":"#/$defs/elaboration_term"}},"required":["kind","term"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/elaboration_term"},"type":"array"},"helper":{"enum":["all","complete","preserves","reaches","search_ok","sound","star"]},"kind":{"const":"helper"}},"required":["arguments","helper","kind"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/formula"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/formula"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"true"}},"required":["kind"],"type":"object"}]},"generatedTheorem":{"additionalProperties":false,"properties":{"name":{"minLength":1,"type":"string"},"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"statement":{"$ref":"#/$defs/formula"},"template":{"enum":["accept_sound","conclude_accept","conclude_sound","explained_forward","explained_generate","explained_search","extend","fire_cases","next_progress","next_sound","replay_fire","replay_sound","run_invariant","search_count","search_growth","search_peak","search_step","step_count","step_none","step_some","step_trace","successors_bound","successors_free","term","try_count","try_sound","unfold","verdict_forward","verdict_generate","verdict_search","verify_sound"]},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["name","parameters","statement","template","type_parameters"],"type":"object"},"module":{"additionalProperties":false,"properties":{"core":{"$ref":"#/$defs/semanticValue"},"declarations":{"items":{"$ref":"#/$defs/declaration"},"type":"array"},"glossary":{"items":{"type":"string"},"type":"array"},"imports":{"items":{"type":"string"},"type":"array"},"lean_module":{"minLength":1,"type":"string"},"linked_ir":{"$ref":"#/$defs/semanticValue"},"name":{"minLength":1,"type":"string"},"origin":{"minLength":1,"type":"string"},"semantic":{"$ref":"#/$defs/semanticModule"},"source":{"$ref":"#/$defs/source"},"visible_packages":{"items":{"type":"string"},"type":"array"}},"required":["declarations","glossary","imports","lean_module","linked_ir","name","source","visible_packages"],"type":"object"},"obligation":{"additionalProperties":false,"properties":{"parameters":{"items":{"$ref":"#/$defs/elaboration_parameter"},"type":"array"},"role":{"minLength":1,"type":"string"},"statement":{"$ref":"#/$defs/elaboration_term"},"theorem":{"$ref":"#/$defs/elaboration_member"},"type_parameters":{"items":{"$ref":"#/$defs/elaboration_name"},"type":"array"}},"required":["parameters","role","statement","theorem","type_parameters"],"type":"object"},"origin":{"additionalProperties":false,"properties":{"proof":{"$ref":"#/$defs/range"},"proof_steps":{"items":{"$ref":"#/$defs/range"},"type":"array"},"sentence":{"$ref":"#/$defs/range"},"whole":{"$ref":"#/$defs/range"}},"required":["proof_steps","sentence","whole"],"type":"object"},"range":{"additionalProperties":false,"properties":{"end":{"minimum":0,"type":"integer"},"start":{"minimum":0,"type":"integer"}},"required":["end","start"],"type":"object"},"semanticModule":{"additionalProperties":false,"properties":{"declarations":{"items":{"$ref":"#/$defs/semantic_declaration"},"minItems":1,"type":"array"},"spec":{"const":"lexlean/semantic-module/2"}},"required":["declarations","spec"],"type":"object"},"semanticValue":{"oneOf":[{"type":"boolean"},{"type":"integer"},{"type":"string"},{"items":{"$ref":"#/$defs/semanticValue"},"type":"array"},{"additionalProperties":{"$ref":"#/$defs/semanticValue"},"type":"object"}]},"semantic_artifactSchema":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"bytes"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"enum":["int16","int32","int64","int8","uint16","uint32","uint64","uint8"]},"kind":{"const":"int_tensor"},"shape":{"items":{"minimum":1,"type":"integer"},"minItems":1,"type":"array"}},"required":["element","kind","shape"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"utf8_lines"}},"required":["kind"],"type":"object"}]},"semantic_assignment":{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/semantic_name"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["field","value"],"type":"object"},"semantic_branch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/semantic_term"},"constructor":{"$ref":"#/$defs/semantic_member"}},"required":["binders","body","constructor"],"type":"object"},"semantic_claim":{"oneOf":[{"additionalProperties":false,"properties":{"agreements":{"minimum":0,"type":"integer"},"comparison":{"$ref":"#/$defs/semantic_member"},"comparison_sound":{"$ref":"#/$defs/semantic_member"},"dataset":{"$ref":"#/$defs/semantic_member"},"examples":{"minimum":0,"type":"integer"},"kind":{"const":"dataset_agreement"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["agreements","comparison","comparison_sound","dataset","examples","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"equivalent_to"},"reference":{"$ref":"#/$defs/semantic_modelUse"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","reference","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"preserves_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"satisfies_contract"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"}]},"semantic_compositeForm":{"oneOf":[{"additionalProperties":false,"properties":{"junctions":{"items":{"$ref":"#/$defs/semantic_compositeJunction"},"minItems":1,"type":"array"},"kind":{"const":"sequence"},"stages":{"items":{"$ref":"#/$defs/semantic_modelUse"},"minItems":2,"type":"array"}},"required":["junctions","kind","stages"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"fanout"},"left":{"$ref":"#/$defs/semantic_modelUse"},"right":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/semantic_modelUse"},"right":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"else":{"$ref":"#/$defs/semantic_modelUse"},"guard":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"branch"},"then":{"$ref":"#/$defs/semantic_modelUse"}},"required":["else","guard","kind","then"],"type":"object"},{"additionalProperties":false,"properties":{"junction":{"$ref":"#/$defs/semantic_compositeJunction"},"kind":{"const":"scan"},"stage":{"$ref":"#/$defs/semantic_modelUse"}},"required":["junction","kind","stage"],"type":"object"}]},"semantic_compositeJunction":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"unconditional"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"evidence":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"proved"}},"required":["evidence","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"checked"}},"required":["kind"],"type":"object"}]},"semantic_constructor":{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["fields","name"],"type":"object"},"semantic_contractState":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"next":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","next","type"],"type":"object"},"semantic_contractValidator":{"additionalProperties":false,"properties":{"complete":{"$ref":"#/$defs/semantic_member"},"predicate":{"enum":["invariant","postcondition","precondition"]},"sound":{"$ref":"#/$defs/semantic_member"},"validator":{"$ref":"#/$defs/semantic_member"}},"required":["predicate","sound","validator"],"type":"object"},"semantic_declaration":{"oneOf":[{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_field"},"minItems":1,"type":"array"},"kind":{"const":"structure"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_field"},"minItems":1,"type":"array"},"kind":{"const":"class"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["fields","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"class":{"$ref":"#/$defs/semantic_member"},"fields":{"items":{"$ref":"#/$defs/semantic_assignment"},"minItems":1,"type":"array"},"kind":{"const":"instance"},"name":{"$ref":"#/$defs/semantic_name"},"priority":{"const":1000}},"required":["arguments","class","fields","kind","name","priority"],"type":"object"},{"additionalProperties":false,"properties":{"constructors":{"items":{"$ref":"#/$defs/semantic_constructor"},"minItems":1,"type":"array"},"kind":{"const":"inductive"},"mutual":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["constructors","kind","name","parameters","type_parameters"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"body":{"$ref":"#/$defs/semantic_term"},"executable":{"type":"boolean"},"kind":{"const":"definition"},"mutual":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"production":{"$ref":"#/$defs/semantic_production"},"recursive_argument":{"$ref":"#/$defs/semantic_name"},"result":{"$ref":"#/$defs/semantic_type"},"termination":{"additionalProperties":false,"properties":{"evidence":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array"},"measure":{"$ref":"#/$defs/semantic_term"}},"required":["evidence","measure"],"type":"object"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["body","kind","name","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"theorem"},"name":{"$ref":"#/$defs/semantic_name"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"type":"array"},"proof":{"$ref":"#/$defs/semantic_proof"},"statement":{"$ref":"#/$defs/semantic_term"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["kind","name","parameters","proof","statement"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"artifact"},"length":{"minimum":0,"type":"integer"},"name":{"$ref":"#/$defs/semantic_name"},"role":{"enum":["binary","dataset","parameters","table","vocabulary"]},"schema":{"$ref":"#/$defs/semantic_artifactSchema"},"sha256":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["kind","length","name","role","schema","sha256","type"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"input":{"$ref":"#/$defs/semantic_modelBinder"},"invariant":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"contract"},"name":{"$ref":"#/$defs/semantic_name"},"output":{"$ref":"#/$defs/semantic_modelBinder"},"postcondition":{"$ref":"#/$defs/semantic_member"},"precondition":{"$ref":"#/$defs/semantic_member"},"state":{"$ref":"#/$defs/semantic_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"validators":{"items":{"$ref":"#/$defs/semantic_contractValidator"},"type":"array"}},"required":["input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"descriptor":{"$ref":"#/$defs/semantic_descriptor"},"executable":{"type":"boolean"},"input":{"$ref":"#/$defs/semantic_modelBinder"},"kind":{"const":"realization"},"name":{"$ref":"#/$defs/semantic_name"},"output":{"$ref":"#/$defs/semantic_type"},"state":{"$ref":"#/$defs/semantic_realizationState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["descriptor","input","kind","name","output"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/semantic_claim"},"minItems":1,"type":"array"},"contract":{"$ref":"#/$defs/semantic_modelUse"},"kind":{"const":"evidence"},"name":{"$ref":"#/$defs/semantic_name"},"realization":{"$ref":"#/$defs/semantic_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["claims","contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"contract":{"$ref":"#/$defs/semantic_modelUse"},"entry":{"items":{"$ref":"#/$defs/semantic_member"},"type":"array"},"evidence":{"items":{"$ref":"#/$defs/semantic_modelUse"},"type":"array"},"kind":{"const":"model"},"name":{"$ref":"#/$defs/semantic_name"},"realization":{"$ref":"#/$defs/semantic_modelUse"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["contract","kind","name","realization"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"invariant":{"$ref":"#/$defs/semantic_logicInvariant"},"kind":{"const":"logic"},"name":{"$ref":"#/$defs/semantic_name"},"ranking":{"$ref":"#/$defs/semantic_member"},"relation":{"$ref":"#/$defs/semantic_member"},"state":{"$ref":"#/$defs/semantic_contractState"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["kind","name","relation","state"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"binding":{"$ref":"#/$defs/semantic_ruleBinding"},"conclusion":{"$ref":"#/$defs/semantic_term"},"executable":{"type":"boolean"},"guard":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"inference_rule"},"logic":{"$ref":"#/$defs/semantic_modelUse"},"name":{"$ref":"#/$defs/semantic_name"},"progress":{"$ref":"#/$defs/semantic_member"},"soundness":{"$ref":"#/$defs/semantic_member"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["conclusion","guard","kind","logic","name","soundness"],"type":"object"},{"additionalProperties":false,"properties":{"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"candidate":{"$ref":"#/$defs/semantic_modelBinder"},"check":{"$ref":"#/$defs/semantic_member"},"complete":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"verifier"},"name":{"$ref":"#/$defs/semantic_name"},"sound":{"$ref":"#/$defs/semantic_member"},"specification":{"$ref":"#/$defs/semantic_member"},"subject":{"$ref":"#/$defs/semantic_modelBinder"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true}},"required":["candidate","check","kind","name","sound","specification","subject"],"type":"object"},{"additionalProperties":false,"properties":{"answer":{"$ref":"#/$defs/semantic_reasoningAnswer"},"axioms":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"claims":{"items":{"$ref":"#/$defs/semantic_reasoningClaim"},"type":"array"},"executable":{"type":"boolean"},"kind":{"const":"reasoner"},"logic":{"$ref":"#/$defs/semantic_modelUse"},"name":{"$ref":"#/$defs/semantic_name"},"observation":{"$ref":"#/$defs/semantic_modelBinder"},"observe":{"$ref":"#/$defs/semantic_term"},"rules":{"items":{"$ref":"#/$defs/semantic_modelUse"},"type":"array"},"strategy":{"$ref":"#/$defs/semantic_reasoningStrategy"},"type_parameters":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"verifier":{"$ref":"#/$defs/semantic_modelUse"}},"required":["kind","name","observation","rules","strategy","verifier"],"type":"object"}]},"semantic_descriptor":{"oneOf":[{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"deterministic"}},"required":["body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"default":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"rule"},"rules":{"items":{"$ref":"#/$defs/semantic_realizationRule"},"minItems":1,"type":"array"}},"required":["default","kind","rules"],"type":"object"},{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/semantic_member"},"features":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"statistical"},"labels":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"},"scheme":{"const":"linear_scoring"},"weights":{"$ref":"#/$defs/semantic_member"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/semantic_member"}},"required":["bias","features","kind","labels","scheme","weights","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"architecture":{"const":"integer_feedforward"},"decoder":{"$ref":"#/$defs/semantic_neuralDecoder"},"encoder":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"neural"},"layers":{"items":{"$ref":"#/$defs/semantic_neuralLayer"},"minItems":1,"type":"array"},"width":{"minimum":1,"type":"integer"},"width_evidence":{"$ref":"#/$defs/semantic_member"}},"required":["architecture","decoder","encoder","kind","layers","width","width_evidence"],"type":"object"},{"additionalProperties":false,"properties":{"form":{"$ref":"#/$defs/semantic_compositeForm"},"kind":{"const":"composite"}},"required":["form","kind"],"type":"object"}]},"semantic_field":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_logicInvariant":{"additionalProperties":false,"properties":{"predicate":{"$ref":"#/$defs/semantic_member"},"preserves":{"$ref":"#/$defs/semantic_member"}},"required":["predicate","preserves"],"type":"object"},"semantic_member":{"additionalProperties":false,"properties":{"module":{"$ref":"#/$defs/semantic_name"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["name"],"type":"object"},"semantic_modelBinder":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_modelUse":{"additionalProperties":false,"properties":{"member":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["member"],"type":"object"},"semantic_name":{"pattern":"^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)*$","type":"string"},"semantic_neuralDecoder":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"argmax"},"labels":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"}},"required":["kind","labels"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_name"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"function"}},"required":["binder","body","kind"],"type":"object"}]},"semantic_neuralLayer":{"oneOf":[{"additionalProperties":false,"properties":{"bias":{"$ref":"#/$defs/semantic_member"},"inputs":{"minimum":1,"type":"integer"},"kind":{"const":"dense"},"outputs":{"minimum":1,"type":"integer"},"weights":{"$ref":"#/$defs/semantic_member"}},"required":["bias","inputs","kind","outputs","weights"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"relu"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"requantize"},"maximum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"minimum":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]},"shift":{"maximum":4096,"minimum":0,"type":"integer"}},"required":["kind","maximum","minimum","shift"],"type":"object"}]},"semantic_parameter":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["name","type"],"type":"object"},"semantic_production":{"additionalProperties":false,"properties":{"effects":{"items":{"enum":["allocation","overflow","recursion"]},"type":"array","uniqueItems":true},"targets":{"items":{"enum":["rust-core","rust-std"]},"minItems":1,"type":"array","uniqueItems":true}},"required":["effects","targets"],"type":"object"},"semantic_proof":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"reflexivity"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"decide"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"simplify"}},"required":["definitions","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proof"},"minItems":1,"type":"array"},"kind":{"const":"constructor"}},"required":["branches","kind"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proofBranch"},"minItems":1,"type":"array"},"kind":{"const":"cases"},"scrutinee":{"$ref":"#/$defs/semantic_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_proofBranch"},"minItems":1,"type":"array"},"generalizing":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"induction"},"scrutinee":{"$ref":"#/$defs/semantic_name"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"congruence"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"boolean_reflection"},"reflection":{"$ref":"#/$defs/semantic_reflection"}},"required":["kind","reflection"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"law"},"name":{"$ref":"#/$defs/semantic_name"},"premises":{"items":{"$ref":"#/$defs/semantic_member"},"type":"array"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"apply"},"theorem":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"definitions":{"items":{"$ref":"#/$defs/semantic_member"},"minItems":1,"type":"array","uniqueItems":true},"kind":{"const":"linear_arithmetic"}},"required":["kind"],"type":"object"}]},"semantic_proofBranch":{"additionalProperties":false,"properties":{"binders":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"constructor":{"$ref":"#/$defs/semantic_name"},"proof":{"$ref":"#/$defs/semantic_proof"}},"required":["binders","constructor","proof"],"type":"object"},"semantic_realizationRule":{"additionalProperties":false,"properties":{"action":{"$ref":"#/$defs/semantic_term"},"guard":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["action","guard","name"],"type":"object"},"semantic_realizationState":{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["initial","name","type"],"type":"object"},"semantic_reasoningAnswer":{"additionalProperties":false,"properties":{"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["name","type","value"],"type":"object"},"semantic_reasoningClaim":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"answer_correct"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"initial_invariant"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"},{"additionalProperties":false,"properties":{"initial":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"observation_invariant"},"predicate":{"$ref":"#/$defs/semantic_member"},"preserved":{"$ref":"#/$defs/semantic_member"}},"required":["initial","kind","predicate","preserved"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"terminates"},"theorem":{"$ref":"#/$defs/semantic_member"}},"required":["kind","theorem"],"type":"object"}]},"semantic_reasoningStrategy":{"oneOf":[{"additionalProperties":false,"properties":{"fuel":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"forward"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"budget":{"$ref":"#/$defs/semantic_term"},"generator":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"generate_and_verify"}},"required":["generator","kind"],"type":"object"},{"additionalProperties":false,"properties":{"deduplicate":{"type":"boolean"},"frontier":{"$ref":"#/$defs/semantic_term"},"fuel":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"search"},"order":{"enum":["breadth_first","depth_first"]}},"required":["kind","order"],"type":"object"}]},"semantic_reflection":{"oneOf":[{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/semantic_member"},"comparison":{"$ref":"#/$defs/semantic_reflectionComparison"},"kind":{"const":"list"},"parameter":{"$ref":"#/$defs/semantic_name"},"proposition_definition":{"$ref":"#/$defs/semantic_member"},"values":{"$ref":"#/$defs/semantic_name"}},"required":["boolean_definition","comparison","kind","parameter","proposition_definition","values"],"type":"object"},{"additionalProperties":false,"properties":{"boolean_definition":{"$ref":"#/$defs/semantic_member"},"fields":{"items":{"$ref":"#/$defs/semantic_reflectionField"},"minItems":1,"type":"array"},"kind":{"const":"record"},"proposition_definition":{"$ref":"#/$defs/semantic_member"},"record":{"$ref":"#/$defs/semantic_name"}},"required":["boolean_definition","fields","kind","proposition_definition","record"],"type":"object"}]},"semantic_reflectionComparison":{"enum":["nat_beq","nat_blt"]},"semantic_reflectionField":{"additionalProperties":false,"properties":{"expected":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]},"field":{"$ref":"#/$defs/semantic_name"}},"required":["expected","field"],"type":"object"},"semantic_ruleBinding":{"additionalProperties":false,"properties":{"candidates":{"$ref":"#/$defs/semantic_term"},"name":{"$ref":"#/$defs/semantic_name"},"type":{"$ref":"#/$defs/semantic_type"}},"required":["candidates","name","type"],"type":"object"},"semantic_term":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"var"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"nat"},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"bool"},"value":{"type":"boolean"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["int","int8","int16","int32","int64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"},{"pattern":"^-[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"integer"},"representation":{"enum":["uint8","uint16","uint32","uint64"]},"value":{"oneOf":[{"const":"0"},{"pattern":"^[1-9][0-9]*$","type":"string"}]}},"required":["kind","representation","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"string"},"value":{"type":"string"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"hex":{"pattern":"^([0-9a-f]{2})*$","type":"string"},"kind":{"const":"bytes"}},"required":["hex","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"primitive"},"operation":{"enum":["append","bit_and","bit_not","bit_or","bit_xor","checked_add","checked_convert","checked_multiply","checked_negate","checked_quotient","checked_subtract","compare_bytes","equal","format_decimal","graph_reachable","graph_successors","graph_topological","index","iterate","iterate_until","join","length","less_than","list_fold","map_contains","map_entries","map_fold","map_insert","map_keys","map_lookup","map_remove","map_size","map_values","multiply","negate","parse_decimal","quotient","remainder","set_contains","set_difference","set_elements","set_fold","set_insert","set_intersection","set_remove","set_size","set_union","shift_left","shift_right","slice","split_exact","subtract","utf8_decode","utf8_encode"]},"result":{"$ref":"#/$defs/semantic_type"}},"required":["arguments","kind","operation","result"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"unit"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"nil"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"head":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"cons"},"tail":{"$ref":"#/$defs/semantic_term"}},"required":["head","kind","tail"],"type":"object"},{"additionalProperties":false,"properties":{"fields":{"items":{"$ref":"#/$defs/semantic_assignment"},"type":"array"},"kind":{"const":"record"},"type":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["fields","kind","type"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"constructor":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"constructor"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","constructor","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"class":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"instance_value"},"resolved":{"$ref":"#/$defs/semantic_member"}},"required":["arguments","class","kind","resolved"],"type":"object"},{"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/semantic_name"},"kind":{"const":"project"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["field","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"function":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"call"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"condition":{"$ref":"#/$defs/semantic_term"},"else_value":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"if"},"then_value":{"$ref":"#/$defs/semantic_term"}},"required":["condition","else_value","kind","then_value"],"type":"object"},{"additionalProperties":false,"properties":{"branches":{"items":{"$ref":"#/$defs/semantic_branch"},"minItems":1,"type":"array"},"kind":{"const":"match"},"scrutinee":{"$ref":"#/$defs/semantic_term"}},"required":["branches","kind","scrutinee"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"eq"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"le"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"lt"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"add"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"beq"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"ble"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"blt"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"and"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"or"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"iff"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"conclusion":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"implies"},"premise":{"$ref":"#/$defs/semantic_term"}},"required":["conclusion","kind","premise"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"not"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_parameter"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"forall"}},"required":["binder","body","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"prop_and"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"binder":{"$ref":"#/$defs/semantic_parameter"},"body":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"let"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["binder","body","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"pair"},"left":{"$ref":"#/$defs/semantic_term"},"right":{"$ref":"#/$defs/semantic_term"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"first"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"second"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"body":{"$ref":"#/$defs/semantic_term"},"captures":{"items":{"$ref":"#/$defs/semantic_name"},"type":"array","uniqueItems":true},"kind":{"const":"lambda"},"parameters":{"items":{"$ref":"#/$defs/semantic_parameter"},"minItems":1,"type":"array"}},"required":["body","captures","kind","parameters"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"minItems":1,"type":"array"},"function":{"$ref":"#/$defs/semantic_term"},"kind":{"const":"apply"}},"required":["arguments","function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"function":{"$ref":"#/$defs/semantic_member"},"kind":{"const":"function_ref"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["function","kind"],"type":"object"},{"additionalProperties":false,"properties":{"entries":{"items":{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/semantic_term"},"value":{"$ref":"#/$defs/semantic_term"}},"required":["key","value"],"type":"object"},"type":"array"},"key":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"map_literal"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["entries","key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"elements":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"kind":{"const":"set_literal"}},"required":["element","elements","kind"],"type":"object"},{"additionalProperties":false,"properties":{"edges":{"items":{"additionalProperties":false,"properties":{"source":{"$ref":"#/$defs/semantic_term"},"target":{"$ref":"#/$defs/semantic_term"}},"required":["source","target"],"type":"object"},"type":"array"},"kind":{"const":"graph_literal"},"node":{"$ref":"#/$defs/semantic_type"},"nodes":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"}},"required":["edges","kind","node","nodes"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_term"},"type":"array"},"checks":{"items":{"enum":["input_invariant","output_invariant","postcondition","precondition"]},"type":"array","uniqueItems":true},"kind":{"const":"checked_apply"},"model":{"$ref":"#/$defs/semantic_member"},"type_arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"}},"required":["arguments","checks","kind","model"],"type":"object"}]},"semantic_type":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"enum":["bool","bytes","int","int8","int16","int32","int64","nat","ordering","prop","string","type","uint8","uint16","uint32","uint64","unit"]}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"parameter"},"name":{"$ref":"#/$defs/semantic_name"}},"required":["kind","name"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"list"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"arguments":{"items":{"$ref":"#/$defs/semantic_type"},"type":"array"},"kind":{"const":"named"},"member":{"$ref":"#/$defs/semantic_member"}},"required":["arguments","kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"option"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"error":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"result"},"ok":{"$ref":"#/$defs/semantic_type"}},"required":["error","kind","ok"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"product"},"left":{"$ref":"#/$defs/semantic_type"},"right":{"$ref":"#/$defs/semantic_type"}},"required":["kind","left","right"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"function"},"parameters":{"items":{"$ref":"#/$defs/semantic_type"},"minItems":1,"type":"array"},"result":{"$ref":"#/$defs/semantic_type"}},"required":["kind","parameters","result"],"type":"object"},{"additionalProperties":false,"properties":{"key":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"map"},"value":{"$ref":"#/$defs/semantic_type"}},"required":["key","kind","value"],"type":"object"},{"additionalProperties":false,"properties":{"element":{"$ref":"#/$defs/semantic_type"},"kind":{"const":"set"}},"required":["element","kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"contract_violation"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"reasoning_failure"}},"required":["kind"],"type":"object"}]},"source":{"additionalProperties":false,"properties":{"path":{"minLength":1,"type":"string"},"sha256":{"$ref":"#/$defs/digest"}},"required":["path","sha256"],"type":"object"}},"$id":"https://github.com/afflom/lexlean/schemas/semantic-snapshot-v2.schema.json","$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"compiler_semantics_id":{"$ref":"#/$defs/digest"},"language":{"const":"1.2"},"lexicon_closure":{"$ref":"#/$defs/semanticValue"},"modules":{"items":{"$ref":"#/$defs/module"},"type":"array"},"semantic_id":{"$ref":"#/$defs/digest"},"source_id":{"$ref":"#/$defs/digest"},"spec":{"const":"lexlean/semantic-snapshot/2"}},"required":["compiler_semantics_id","language","lexicon_closure","modules","semantic_id","source_id","spec"],"title":"LexLean language-1.2 semantic snapshot","type":"object"} diff --git a/tests/packages/workspace/app/lake-manifest.json b/tests/packages/workspace/app/lake-manifest.json new file mode 100644 index 000000000..ac5f80ca4 --- /dev/null +++ b/tests/packages/workspace/app/lake-manifest.json @@ -0,0 +1,6 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [], + "name": "app_host", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/tests/packages/workspace/app/lakefile.toml b/tests/packages/workspace/app/lakefile.toml new file mode 100644 index 000000000..80fc48e91 --- /dev/null +++ b/tests/packages/workspace/app/lakefile.toml @@ -0,0 +1,2 @@ +name = "app_host" +version = "0.1.0" diff --git a/tests/packages/workspace/app/lean-toolchain b/tests/packages/workspace/app/lean-toolchain new file mode 100644 index 000000000..2b61957be --- /dev/null +++ b/tests/packages/workspace/app/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.32.1 diff --git a/tests/packages/workspace/app/lexlean.toml b/tests/packages/workspace/app/lexlean.toml new file mode 100644 index 000000000..30208af48 --- /dev/null +++ b/tests/packages/workspace/app/lexlean.toml @@ -0,0 +1,33 @@ +spec = "lexlean/project/1" +name = "app" +language = "1.2" +module_prefix = "PkgApp" +source_roots = ["src"] +entrypoints = ["src/Main.lex.tex"] +build_root = ".lexlean" +lockfile = "lexlean.lock" +lean_workspace = "." +lean_toolchain = "leanprover/lean4:v4.32.1" + +[[lexicon_source]] +package = "lexlean.std.nat" +kind = "builtin" + +[[source_package]] +package = "lib" +version = "1.0.0" +kind = "path" +path = "lib" + +[limits] +max_file_bytes = 4194304 +max_total_source_bytes = 67108864 +max_primitive_atoms = 2000000 +max_token_lattice_edges = 4000000 +max_parse_states = 4000000 +max_ir_nodes = 2000000 +max_scope_depth = 1024 +max_import_depth = 128 +max_diagnostics = 256 +max_child_output_bytes = 16777216 +child_timeout_ms = 300000 diff --git a/tests/packages/workspace/app/src/Main.lex.tex b/tests/packages/workspace/app/src/Main.lex.tex new file mode 100644 index 000000000..238e13714 --- /dev/null +++ b/tests/packages/workspace/app/src/Main.lex.tex @@ -0,0 +1,22 @@ +\begin{lexlean}{Main} +\useglossary{lexlean.std.nat@1.2.0} +\importmodule{PkgLib.Util} +\title{Natural number addition} +\begin{semanticmodule} +definition{ + name: appValue, + parameters: [n : Nat], + result: Nat, + body: (PkgLib.Util::quadPlusOne n), + executable: true, + production: {effects: [overflow], targets: [rust-core, rust-std]} +} + +theorem{ + name: app_value_two, + parameters: [], + statement: ((appValue 2) = 9), + proof: reflexivity{} +} +\end{semanticmodule} +\end{lexlean} diff --git a/tests/packages/workspace/base/lake-manifest.json b/tests/packages/workspace/base/lake-manifest.json new file mode 100644 index 000000000..3d4f66162 --- /dev/null +++ b/tests/packages/workspace/base/lake-manifest.json @@ -0,0 +1,6 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [], + "name": "base_host", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/tests/packages/workspace/base/lakefile.toml b/tests/packages/workspace/base/lakefile.toml new file mode 100644 index 000000000..e5c34d0aa --- /dev/null +++ b/tests/packages/workspace/base/lakefile.toml @@ -0,0 +1,2 @@ +name = "base_host" +version = "0.1.0" diff --git a/tests/packages/workspace/base/lean-toolchain b/tests/packages/workspace/base/lean-toolchain new file mode 100644 index 000000000..2b61957be --- /dev/null +++ b/tests/packages/workspace/base/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.32.1 diff --git a/tests/packages/workspace/base/lexlean.toml b/tests/packages/workspace/base/lexlean.toml new file mode 100644 index 000000000..21ef63d10 --- /dev/null +++ b/tests/packages/workspace/base/lexlean.toml @@ -0,0 +1,27 @@ +spec = "lexlean/project/1" +name = "base" +language = "1.2" +module_prefix = "PkgBase" +source_roots = ["src"] +entrypoints = ["src/Core.lex.tex"] +build_root = ".lexlean" +lockfile = "lexlean.lock" +lean_workspace = "." +lean_toolchain = "leanprover/lean4:v4.32.1" + +[[lexicon_source]] +package = "lexlean.std.nat" +kind = "builtin" + +[limits] +max_file_bytes = 4194304 +max_total_source_bytes = 67108864 +max_primitive_atoms = 2000000 +max_token_lattice_edges = 4000000 +max_parse_states = 4000000 +max_ir_nodes = 2000000 +max_scope_depth = 1024 +max_import_depth = 128 +max_diagnostics = 256 +max_child_output_bytes = 16777216 +child_timeout_ms = 300000 diff --git a/tests/packages/workspace/base/src/Core.lex.tex b/tests/packages/workspace/base/src/Core.lex.tex new file mode 100644 index 000000000..fd4fd17a6 --- /dev/null +++ b/tests/packages/workspace/base/src/Core.lex.tex @@ -0,0 +1,16 @@ +\begin{lexlean}{Core} +\useglossary{lexlean.std.nat@1.2.0} +\title{Natural number addition} +\begin{semanticmodule} +definition{ + name: twice, + parameters: [n : Nat], + result: Nat, + body: (n + n), + executable: true, + production: {effects: [overflow], targets: [rust-core, rust-std]} +} + +theorem{name: twice_two, parameters: [], statement: ((twice 2) = 4), proof: reflexivity{}} +\end{semanticmodule} +\end{lexlean} diff --git a/tests/packages/workspace/lexlean-workspace.toml b/tests/packages/workspace/lexlean-workspace.toml new file mode 100644 index 000000000..0ef978bad --- /dev/null +++ b/tests/packages/workspace/lexlean-workspace.toml @@ -0,0 +1,2 @@ +spec = "lexlean/workspace/1" +members = ["app", "base", "lib"] diff --git a/tests/packages/workspace/lib/lake-manifest.json b/tests/packages/workspace/lib/lake-manifest.json new file mode 100644 index 000000000..2e464cab9 --- /dev/null +++ b/tests/packages/workspace/lib/lake-manifest.json @@ -0,0 +1,6 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [], + "name": "lib_host", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/tests/packages/workspace/lib/lakefile.toml b/tests/packages/workspace/lib/lakefile.toml new file mode 100644 index 000000000..892711688 --- /dev/null +++ b/tests/packages/workspace/lib/lakefile.toml @@ -0,0 +1,2 @@ +name = "lib_host" +version = "0.1.0" diff --git a/tests/packages/workspace/lib/lean-toolchain b/tests/packages/workspace/lib/lean-toolchain new file mode 100644 index 000000000..2b61957be --- /dev/null +++ b/tests/packages/workspace/lib/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.32.1 diff --git a/tests/packages/workspace/lib/lexlean.toml b/tests/packages/workspace/lib/lexlean.toml new file mode 100644 index 000000000..4212c4e7c --- /dev/null +++ b/tests/packages/workspace/lib/lexlean.toml @@ -0,0 +1,33 @@ +spec = "lexlean/project/1" +name = "lib" +language = "1.2" +module_prefix = "PkgLib" +source_roots = ["src"] +entrypoints = ["src/Util.lex.tex"] +build_root = ".lexlean" +lockfile = "lexlean.lock" +lean_workspace = "." +lean_toolchain = "leanprover/lean4:v4.32.1" + +[[lexicon_source]] +package = "lexlean.std.nat" +kind = "builtin" + +[[source_package]] +package = "base" +version = "1.0.0" +kind = "path" +path = "base" + +[limits] +max_file_bytes = 4194304 +max_total_source_bytes = 67108864 +max_primitive_atoms = 2000000 +max_token_lattice_edges = 4000000 +max_parse_states = 4000000 +max_ir_nodes = 2000000 +max_scope_depth = 1024 +max_import_depth = 128 +max_diagnostics = 256 +max_child_output_bytes = 16777216 +child_timeout_ms = 300000 diff --git a/tests/packages/workspace/lib/src/Shapes.lex.tex b/tests/packages/workspace/lib/src/Shapes.lex.tex new file mode 100644 index 000000000..c7f046174 --- /dev/null +++ b/tests/packages/workspace/lib/src/Shapes.lex.tex @@ -0,0 +1,14 @@ +\begin{lexlean}{Shapes} +\useglossary{lexlean.std.nat@1.2.0} +\importmodule{PkgBase.Core} +\title{Natural number addition} +\begin{semanticmodule} +definition{ + name: quad, + parameters: [n : Nat], + result: Nat, + body: (PkgBase.Core::twice (PkgBase.Core::twice n)), + executable: true +} +\end{semanticmodule} +\end{lexlean} diff --git a/tests/packages/workspace/lib/src/Util.lex.tex b/tests/packages/workspace/lib/src/Util.lex.tex new file mode 100644 index 000000000..9deb76d83 --- /dev/null +++ b/tests/packages/workspace/lib/src/Util.lex.tex @@ -0,0 +1,22 @@ +\begin{lexlean}{Util} +\useglossary{lexlean.std.nat@1.2.0} +\importmodule{Shapes} +\title{Natural number addition} +\begin{semanticmodule} +definition{ + name: quadPlusOne, + parameters: [n : Nat], + result: Nat, + body: ((Shapes::quad n) + 1), + executable: true, + production: {effects: [overflow], targets: [rust-core, rust-std]} +} + +theorem{ + name: quad_plus_one_two, + parameters: [], + statement: ((quadPlusOne 2) = 9), + proof: reflexivity{} +} +\end{semanticmodule} +\end{lexlean} diff --git a/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index 462cc4c5b..905a96411 100644 --- a/xtask/src/spec_links.rs +++ b/xtask/src/spec_links.rs @@ -61,8 +61,8 @@ fn parse_table(spec: &str) -> Result, Fail> { pub fn validate(root: &Path) -> Result<(), Fail> { let spec = std::fs::read_to_string(root.join("SPEC.md"))?; let rows = parse_table(&spec)?; - if rows.len() != 392 { - return Err(format!("RP-07: the §31 table has {} rows, not 392", rows.len()).into()); + if rows.len() != 396 { + return Err(format!("RP-07: the §31 table has {} rows, not 396", rows.len()).into()); } // The prose total under the table is part of the contract a reader // relies on; a row added without it would leave §31 contradicting itself. From 3a276caf5257144c2223528c87e1a25857c4daaf Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 02:11:33 +0000 Subject: [PATCH 2/6] docs(packages): SPEC 10.5, the plants, CHANGELOG, README (Refs #161) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- CHANGELOG.md | 21 ++++++++++ README.md | 4 ++ VERIFICATION.md | 52 ++++++++++++++++++++++++ crates/conformance/src/cases/packages.rs | 28 ++++++++++++- crates/lexlean/src/source_package.rs | 29 +++++++++++++ 5 files changed, 132 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3a63d7aa8..285a957cf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,27 @@ versions, and the entries below say what each tag does and does not claim. ## Unreleased +- Source packages (#161, SPEC.md §10.5, `PK-01`..`PK-04`, language 1.2 only). + A project declares `[[source_package]]` tables (`package`, `version`, `kind` + `path`, `path`), each naming a member project of the workspace an optional + `lexlean-workspace.toml` at the repository root lists, and imports its + modules by their own Lean names (`\importmodule{LexLeanStd.Text}`). The lock + gains `[[source_package]]` rows (tree digest over the package's manifest and + source files, manifest digest, version, prefix, its own packages) that every + command recomputes; a changed byte or version is `LLC0105` naming both + digests, a pin for an undeclared package `LLC0106`, a module prefix claimed + twice `LLC0107`, a project or path outside the workspace rule `LLC0108` + (a symlink or an escaping path is `LLS8001`), and an import of a package the + scope does not declare `LLR3009`. A package definition is an ordinary + definition of the importing project: its own `production:` roots are not + roots of the importer and nothing is re-exported. `verify` replays the + package modules under the package's prefix, with the package as their + `origin` in the build manifest, the snapshot, and the attestation; `fmt` + never writes a package file. The schema change moves the language-1.2 + compiler-semantics ID once; languages 1.0 and 1.1, and a language-1.2 project + without source packages, keep their bytes apart from that identity. The + register gains `PK-01`..`PK-04` (396 rows); `PK-05` (the `bootstrap/` pilot + imports `stdlib/`) follows #153 and #160. - Certificate E as kernel-term data (SPEC.md §17.17, `SP-14`; stage 1 of #89, stage 5 of #27). The composition certificate of every production root is no longer written as Lean text by `production/certificate.rs`: the compiler diff --git a/README.md b/README.md index 74e4e6b48..654887d29 100644 --- a/README.md +++ b/README.md @@ -104,6 +104,10 @@ nested byte-data declarations are not restricted by interactive defaults. Project child timeout/output limits and full kernel/axiom verification remain mandatory. These are generated backend settings, not caller-provided options. +## Source packages + +A language-1.2 project imports the modules of another project of its workspace without copying them: `[[source_package]]` in `lexlean.toml` names a member directory listed by `lexlean-workspace.toml`, `lexlean.lock` pins the package by the digest of its manifest and source files, every command recomputes the pin, imports are closed to the project's own modules and the declared packages, and `verify` replays the package's modules under its module prefix with the package as their origin (SPEC.md §10.5, `PK-01`..`PK-04`; the workspace the cases use is [tests/packages/workspace](tests/packages/workspace/)). + ## Examples that verify under the pinned toolchain The [compiler/](compiler/) project defines the production realization calculus (SPEC.md §17.14) in LexLean and passes the same gates as an example; its hand-constructed target programs live under [compiler/fixtures/](compiler/fixtures/). Its `Gnaf` module states GNAF requests over that calculus (SPEC.md §17.15): the complete-system universe, machine contract, and objective order, all fixed before any optimizer, with a kernel-checked theorem that the universe is complete. The requests themselves live under [compiler/gnaf/](compiler/gnaf/), and [compiler/gnaf.manifest.json](compiler/gnaf.manifest.json) is the dependency manifest UOR-GNAF §20 requires. Its `Certification` module checks GNAF certificates (SPEC.md §17.18) under [compiler/certificates/](compiler/certificates/): a global optimum, an argmin, or a complete Pareto frontier is certified from evidence for every system of the universe rather than by enumerating it, with the soundness of the checker proved in [compiler/proofs/](compiler/proofs/); local normality, correctness, and representation-minimality are separate, weaker statuses, and an incomplete certificate names its first open obligation. The target fixtures' Rust packages (§17.16) live under [compiler/rust/](compiler/rust/). diff --git a/VERIFICATION.md b/VERIFICATION.md index 2190980d7..9e39bc941 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -8142,3 +8142,55 @@ prereleases, unrelated occurrences of the pin, and malformed banners. Validated after the fix: the unit case and `conformance_vr_02` pass (the latter in 4.76 s), as do formatting, workspace/all-target Clippy with warnings denied, model/spec-link audits, and all five BDD meta-gate tests. + +### source packages can fail + +The cases of the `packages` suite (`PK-01`..`PK-04`, SPEC.md §10.5) were written +before the implementation (R3). `conformance_pk_01` first failed, with the +configuration, the workspace, and the pins in place and the pin comparison not +yet in `lock --check`, at its first refusal: + +```text +expected LLC0105, found ["LLC0102"] (LLC0102: lexlean.lock is stale or noncanonical; run `lexlean lock`) +``` + +Each defect below was planted, the named case run with +`cargo test -p repo-conformance --test conformance -- --exact --test-threads=1`, +and the defect removed. The observed lines are the cases' own. + +| Planted defect | Case | Observed | +| --- | --- | --- | +| the tree digest covers the manifest alone (a source file of the package is not pinned) | `conformance_pk_01` | `the project is refused`: a changed byte of the package is not refused | +| `check_pins` is not called when linking (a lock read before the package changed is trusted) | `conformance_pk_01` | `linking reads the package again` | +| a project the workspace file does not list is accepted | `conformance_pk_01` | `expected LLC0108, found ["LLC0102"]` | +| a symlink in the path of a package is not refused as such | `conformance_pk_01` | `expected LLS8001, found ["LLC0108"]` | +| two sources may claim one module prefix | `conformance_pk_01` | `two sources claim PkgLib` | +| an import may name a module of any package of the closure | `conformance_pk_02` | `check fails` (the undeclared import is accepted) | +| the production roots of a package are analysed | `conformance_pk_04` | `` `PkgBase.Core`: only the importing project's own roots are analysed `` (left: true) | +| `fmt` visits the modules of a package | `conformance_pk_03` | `` `base:src`: No such file or directory `` (it reads the package as if it were the project) | +| the build manifest names no origin | `conformance_pk_03` | `the manifest names the origin of a package module` | +| the attestation names no origin | `conformance_pk_03` | `the modules of a package carry the package as their origin` (left: `Null`) | + +One plant was not caught where it was first made: removing `check_pins` from +`load_locked` alone left `conformance_pk_03` green, because `read_current_lock` +makes the same comparison first. The comparison at link is the one that reads +the package after the lock was read, so `conformance_pk_01` now links with a +lock read before a byte of the package changed and requires `LLC0105`; the +plant above is the one it caught. + +Measured on Linux x86-64 with Lean 4.32.1: `conformance_pk_01` and +`conformance_pk_02` run in under 3 s, `conformance_pk_03` (the importing +project formatted, built, and verified, with every module replayed and audited) +in 185 s, and `conformance_pk_04` (a root whose closure reaches a definition of +`lib` and of `base` certified and exported) in 188 s. + +Languages 1.0 and 1.1 are unchanged. After the schema change, in a scratch +checkout whose language-1.2 locks were regenerated, `cargo xtask check-golden +--write` left every file of `nat-add-zero`, `peano-arithmetic`, +`propositional-logic`, `list-induction`, `semantic-1.1`, and `uor-atlas` +untouched. The language-1.2 example `language-1.2`, which declares no source +package, differs from its committed oracles in identities and the digests +derived from them alone (the compiler-semantics, source, semantic, and build +IDs, and the digests of its lock and its source map); the committed +language-1.2 records are regenerated in the wave the maintainer names, not by +this change. diff --git a/crates/conformance/src/cases/packages.rs b/crates/conformance/src/cases/packages.rs index dce945777..d50d32fbd 100644 --- a/crates/conformance/src/cases/packages.rs +++ b/crates/conformance/src/cases/packages.rs @@ -179,6 +179,24 @@ fn pk_01() { assert_ne!(observed, locked_digest); assert!(message.contains(&observed), "{message}"); + // Every command that links reads the package again: a lock read before the + // package changed is not the lock of what would be linked. + let direct = P::package_workspace("app"); + direct.relock(); + let loaded = lexlean::project::Project::load(&direct.root.join("lexlean.toml")).expect("loads"); + let (read, resolved) = lexlean::lock::read_current_lock(&loaded).expect("the lock is current"); + edit_raw( + &direct, + "../base/src/Core.lex.tex", + "name: twice_two,", + "name: twice_twoo,", + ); + let stale = + lexlean::link::check_project(&loaded, &lexlean::Selection::Entrypoints, &read, resolved) + .err() + .expect("linking reads the package again"); + support::expect_code(&stale, "LLC0105"); + // The same bytes for a changed manifest of the package. let manifest = P::package_workspace("app"); manifest.relock(); @@ -529,8 +547,14 @@ fn pk_03() { } let manifest = std::fs::read_to_string(build_dir.join("manifest.json").as_std_path()).expect("manifest"); - assert!(manifest.contains("\"origin\":\"lib\""), "{manifest}"); - assert!(manifest.contains("\"origin\":\"base\""), "{manifest}"); + assert!( + manifest.contains("\"origin\":\"lib\""), + "the manifest names the origin of a package module" + ); + assert!( + manifest.contains("\"origin\":\"base\""), + "the manifest names the origin of a package module" + ); assert_eq!(manifest.matches("\"origin\"").count(), 3); // The source ID follows the pins: a byte of the package moves it once diff --git a/crates/lexlean/src/source_package.rs b/crates/lexlean/src/source_package.rs index 07fe6c8b8..485cda73e 100644 --- a/crates/lexlean/src/source_package.rs +++ b/crates/lexlean/src/source_package.rs @@ -741,3 +741,32 @@ pub fn load_locked(project: &Project, lock: &Lock) -> Result Date: Sat, 17 Oct 2026 02:21:00 +0000 Subject: [PATCH 3/6] test(packages): a non-canonical package file stays as its package wrote it; canonical fixture Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- crates/conformance/src/cases/packages.rs | 10 ++++++++-- tests/packages/workspace/app/src/Main.lex.tex | 7 +------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/crates/conformance/src/cases/packages.rs b/crates/conformance/src/cases/packages.rs index d50d32fbd..e80116ce1 100644 --- a/crates/conformance/src/cases/packages.rs +++ b/crates/conformance/src/cases/packages.rs @@ -513,9 +513,15 @@ fn pk_02() { /// PK-03: an importing project builds, verifies, and records the origin. fn pk_03() { let app = P::package_workspace("app"); + // A package file that is not canonical stays as its package wrote it: + // formatting the importing project never rewrites it. + edit_raw( + &app, + "../lib/src/Util.lex.tex", + " name: quadPlusOne,", + " name: quadPlusOne,", + ); app.relock(); - // Formatting never writes a package file, and the formatted project is - // already canonical. let before = package_bytes(&app); let formatted = app .engine() diff --git a/tests/packages/workspace/app/src/Main.lex.tex b/tests/packages/workspace/app/src/Main.lex.tex index 238e13714..d17bbdda7 100644 --- a/tests/packages/workspace/app/src/Main.lex.tex +++ b/tests/packages/workspace/app/src/Main.lex.tex @@ -12,11 +12,6 @@ production: {effects: [overflow], targets: [rust-core, rust-std]} } -theorem{ - name: app_value_two, - parameters: [], - statement: ((appValue 2) = 9), - proof: reflexivity{} -} +theorem{name: app_value_two, parameters: [], statement: ((appValue 2) = 9), proof: reflexivity{}} \end{semanticmodule} \end{lexlean} From bd376aa2eda421a09045088ab5c6b6bd15320f24 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 06:24:35 +0000 Subject: [PATCH 4/6] chore(#161): regenerate the language-1.2 records on the combined tree (source-package schemas; main at d22266b3) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- compiler/expected/build/manifest.json | 2 +- .../maps/LexLeanTarget/BudgetOracle.map.json | 2 +- .../maps/LexLeanTarget/Certification.map.json | 2 +- .../build/maps/LexLeanTarget/Gnaf.map.json | 2 +- .../LexLeanTarget/GnafCertificates.map.json | 2 +- .../maps/LexLeanTarget/GnafFixtures.map.json | 2 +- .../maps/LexLeanTarget/GradeOracle.map.json | 2 +- .../build/maps/LexLeanTarget/Main.map.json | 2 +- .../maps/LexLeanTarget/PlannerOracle.map.json | 2 +- .../LexLeanTarget/ReasoningFixtures.map.json | 2 +- .../LexLeanTarget/ReasoningOracle.map.json | 2 +- .../maps/LexLeanTarget/RustSemantics.map.json | 2 +- .../maps/LexLeanTarget/RustSyntax.map.json | 2 +- .../LexLeanTarget/ScreeningOracle.map.json | 2 +- .../LexLeanTarget/TargetFixtures.map.json | 2 +- .../maps/LexLeanTarget/TargetOracle.map.json | 2 +- .../LexLeanTarget/TargetSemantics.map.json | 2 +- .../maps/LexLeanTarget/TargetSyntax.map.json | 2 +- compiler/lexlean.lock | 2 +- .../arithmetic-invented-overflow.json | 2 +- .../arithmetic-undeclared-overflow.json | 2 +- compiler/rust/negative/export-arity.json | 2 +- .../rust/negative/hidden-allocation-list.json | 2 +- .../hidden-allocation-recursive-type.json | 2 +- .../negative/identifier-exported-twice.json | 2 +- .../rust/negative/identifier-generated.json | 2 +- .../rust/negative/identifier-keyword.json | 2 +- .../negative/identifier-not-snake-case.json | 2 +- .../negative/identifier-reserved-crate.json | 2 +- .../negative/identifier-runtime-function.json | 2 +- .../negative/identifier-runtime-item.json | 2 +- .../negative/malformed-unknown-member.json | 2 +- .../rust/negative/ownership-copy-list.json | 2 +- .../unsupported-function-boundary.json | 2 +- .../unsupported-function-in-record.json | 2 +- .../unsupported-uninhabited-value.json | 2 +- .../rust/negative/version-noncanonical.json | 2 +- compiler/rust/negative/version-overflow.json | 2 +- .../rust-core/boolean-shapes/package.json | 2 +- .../rust-core/boolean-shapes/provenance.json | 2 +- .../rust-core/closure-captures/package.json | 2 +- .../closure-captures/provenance.json | 2 +- .../rust-core/closure-inline/package.json | 2 +- .../rust-core/closure-inline/provenance.json | 2 +- .../closure-uninhabited/package.json | 2 +- .../closure-uninhabited/provenance.json | 2 +- compiler/rust/rust-core/convert/package.json | 2 +- .../rust/rust-core/convert/provenance.json | 2 +- .../fallible-condition-value/package.json | 2 +- .../fallible-condition-value/provenance.json | 2 +- .../rust-core/fixed-width-i16/package.json | 2 +- .../rust-core/fixed-width-i16/provenance.json | 2 +- .../rust-core/fixed-width-i32/package.json | 2 +- .../rust-core/fixed-width-i32/provenance.json | 2 +- .../rust-core/fixed-width-i64/package.json | 2 +- .../rust-core/fixed-width-i64/provenance.json | 2 +- .../rust-core/fixed-width-i8/package.json | 2 +- .../rust-core/fixed-width-i8/provenance.json | 2 +- .../rust-core/fixed-width-u16/package.json | 2 +- .../rust-core/fixed-width-u16/provenance.json | 2 +- .../rust-core/fixed-width-u32/package.json | 2 +- .../rust-core/fixed-width-u32/provenance.json | 2 +- .../rust-core/fixed-width-u64/package.json | 2 +- .../rust-core/fixed-width-u64/provenance.json | 2 +- .../fixed-width-u8-passing/package.json | 2 +- .../fixed-width-u8-passing/provenance.json | 2 +- .../rust-core/fixed-width-u8/package.json | 2 +- .../rust-core/fixed-width-u8/provenance.json | 2 +- .../rust-core/function-shapes/package.json | 2 +- .../rust-core/function-shapes/provenance.json | 2 +- .../rust-core/int-overflow-mul/package.json | 2 +- .../int-overflow-mul/provenance.json | 2 +- .../rust-core/int-overflow-neg/package.json | 2 +- .../int-overflow-neg/provenance.json | 2 +- .../rust-core/int-overflow-quot/package.json | 2 +- .../int-overflow-quot/provenance.json | 2 +- .../rust-core/int-overflow-sub/package.json | 2 +- .../int-overflow-sub/provenance.json | 2 +- .../iterate-until-bounded/package.json | 2 +- .../iterate-until-bounded/provenance.json | 2 +- .../rust/rust-core/iterate-until/package.json | 2 +- .../rust-core/iterate-until/provenance.json | 2 +- compiler/rust/rust-core/iterate/package.json | 2 +- .../rust/rust-core/iterate/provenance.json | 2 +- .../rust/rust-core/match-shapes/package.json | 2 +- .../rust-core/match-shapes/provenance.json | 2 +- .../rust-core/nat-overflow-add/package.json | 2 +- .../nat-overflow-add/provenance.json | 2 +- .../rust-core/nat-overflow-mul/package.json | 2 +- .../nat-overflow-mul/provenance.json | 2 +- .../nat-overflow-nested/package.json | 2 +- .../nat-overflow-nested/provenance.json | 2 +- .../rust-core/nat-overflow-succ/package.json | 2 +- .../nat-overflow-succ/provenance.json | 2 +- .../reasoning-gnaf-goal/package.json | 2 +- .../reasoning-gnaf-goal/provenance.json | 2 +- .../reasoning-gnaf-priority/package.json | 2 +- .../reasoning-gnaf-priority/provenance.json | 2 +- .../reasoning-gnaf-sweep/package.json | 2 +- .../reasoning-gnaf-sweep/provenance.json | 2 +- .../reasoning-grade-shock/package.json | 2 +- .../reasoning-grade-shock/provenance.json | 2 +- .../reasoning-grade-well/package.json | 2 +- .../reasoning-grade-well/provenance.json | 2 +- .../reasoning-review-exhausted/package.json | 2 +- .../provenance.json | 2 +- .../reasoning-review-rejected/package.json | 2 +- .../reasoning-review-rejected/provenance.json | 2 +- .../reasoning-triage-shock/package.json | 2 +- .../reasoning-triage-shock/provenance.json | 2 +- .../reasoning-triage-well/package.json | 2 +- .../reasoning-triage-well/provenance.json | 2 +- .../rust/rust-core/record-fields/package.json | 2 +- .../rust-core/record-fields/provenance.json | 2 +- .../rust-core/sum-to-exhausted/package.json | 2 +- .../sum-to-exhausted/provenance.json | 2 +- compiler/rust/rust-core/sum-to/package.json | 2 +- .../rust/rust-core/sum-to/provenance.json | 2 +- .../rust/rust-core/unit-closures/package.json | 2 +- .../rust-core/unit-closures/provenance.json | 2 +- .../rust/rust-core/unit-values/package.json | 2 +- .../rust-core/unit-values/provenance.json | 2 +- .../rust/rust-core/wide-shapes/package.json | 2 +- .../rust-core/wide-shapes/provenance.json | 2 +- .../rust/rust-std/adt-evaluation/package.json | 2 +- .../rust-std/adt-evaluation/provenance.json | 2 +- .../rust-std/binding-and-shapes/package.json | 2 +- .../binding-and-shapes/provenance.json | 2 +- .../rust/rust-std/boolean-shapes/package.json | 2 +- .../rust-std/boolean-shapes/provenance.json | 2 +- compiler/rust/rust-std/booleans/package.json | 2 +- .../rust/rust-std/booleans/provenance.json | 2 +- .../rust/rust-std/boxed-field/package.json | 2 +- .../rust/rust-std/boxed-field/provenance.json | 2 +- .../rust/rust-std/byte-compare/package.json | 2 +- .../rust-std/byte-compare/provenance.json | 2 +- .../rust/rust-std/byte-order/package.json | 2 +- .../rust/rust-std/byte-order/provenance.json | 2 +- .../rust/rust-std/byte-slices/package.json | 2 +- .../rust/rust-std/byte-slices/provenance.json | 2 +- .../rust/rust-std/bytes-and-text/package.json | 2 +- .../rust-std/bytes-and-text/provenance.json | 2 +- .../rust-std/closure-captures/package.json | 2 +- .../rust-std/closure-captures/provenance.json | 2 +- .../rust-std/closure-dispatch/package.json | 2 +- .../rust-std/closure-dispatch/provenance.json | 2 +- .../rust/rust-std/closure-inline/package.json | 2 +- .../rust-std/closure-inline/provenance.json | 2 +- .../rust-std/closure-recursive/package.json | 2 +- .../closure-recursive/provenance.json | 2 +- .../rust-std/closure-uninhabited/package.json | 2 +- .../closure-uninhabited/provenance.json | 2 +- compiler/rust/rust-std/closures/package.json | 2 +- .../rust/rust-std/closures/provenance.json | 2 +- compiler/rust/rust-std/convert/package.json | 2 +- .../rust/rust-std/convert/provenance.json | 2 +- .../decimal-overflow-wide/package.json | 2 +- .../decimal-overflow-wide/provenance.json | 2 +- .../rust-std/decimal-overflow/package.json | 2 +- .../rust-std/decimal-overflow/provenance.json | 2 +- compiler/rust/rust-std/decimal/package.json | 2 +- .../rust/rust-std/decimal/provenance.json | 2 +- compiler/rust/rust-std/equality/package.json | 2 +- .../rust/rust-std/equality/provenance.json | 2 +- .../fallible-condition-value/package.json | 2 +- .../fallible-condition-value/provenance.json | 2 +- .../rust-std/fixed-bits-signed/package.json | 2 +- .../fixed-bits-signed/provenance.json | 2 +- .../rust-std/fixed-bits-unsigned/package.json | 2 +- .../fixed-bits-unsigned/provenance.json | 2 +- .../fixed-checked-narrow/package.json | 2 +- .../fixed-checked-narrow/provenance.json | 2 +- .../fixed-checked-signed/package.json | 2 +- .../fixed-checked-signed/provenance.json | 2 +- .../rust-std/fixed-checked-wide/package.json | 2 +- .../fixed-checked-wide/provenance.json | 2 +- .../rust-std/fixed-decimal-i16/package.json | 2 +- .../fixed-decimal-i16/provenance.json | 2 +- .../rust-std/fixed-decimal-i32/package.json | 2 +- .../fixed-decimal-i32/provenance.json | 2 +- .../rust-std/fixed-decimal-i64/package.json | 2 +- .../fixed-decimal-i64/provenance.json | 2 +- .../rust-std/fixed-decimal-i8/package.json | 2 +- .../rust-std/fixed-decimal-i8/provenance.json | 2 +- .../rust-std/fixed-decimal-u16/package.json | 2 +- .../fixed-decimal-u16/provenance.json | 2 +- .../rust-std/fixed-decimal-u32/package.json | 2 +- .../fixed-decimal-u32/provenance.json | 2 +- .../rust-std/fixed-decimal-u64/package.json | 2 +- .../fixed-decimal-u64/provenance.json | 2 +- .../rust-std/fixed-decimal-u8/package.json | 2 +- .../rust-std/fixed-decimal-u8/provenance.json | 2 +- .../rust-std/fixed-width-i16/package.json | 2 +- .../rust-std/fixed-width-i16/provenance.json | 2 +- .../rust-std/fixed-width-i32/package.json | 2 +- .../rust-std/fixed-width-i32/provenance.json | 2 +- .../rust-std/fixed-width-i64/package.json | 2 +- .../rust-std/fixed-width-i64/provenance.json | 2 +- .../rust/rust-std/fixed-width-i8/package.json | 2 +- .../rust-std/fixed-width-i8/provenance.json | 2 +- .../rust-std/fixed-width-u16/package.json | 2 +- .../rust-std/fixed-width-u16/provenance.json | 2 +- .../rust-std/fixed-width-u32/package.json | 2 +- .../rust-std/fixed-width-u32/provenance.json | 2 +- .../rust-std/fixed-width-u64/package.json | 2 +- .../rust-std/fixed-width-u64/provenance.json | 2 +- .../fixed-width-u8-passing/package.json | 2 +- .../fixed-width-u8-passing/provenance.json | 2 +- .../rust/rust-std/fixed-width-u8/package.json | 2 +- .../rust-std/fixed-width-u8/provenance.json | 2 +- .../rust-std/function-shapes/package.json | 2 +- .../rust-std/function-shapes/provenance.json | 2 +- .../graph-reachable-absent/package.json | 2 +- .../graph-reachable-absent/provenance.json | 2 +- .../graph-reachable-inner/package.json | 2 +- .../graph-reachable-inner/provenance.json | 2 +- .../rust-std/graph-reachable/package.json | 2 +- .../rust-std/graph-reachable/provenance.json | 2 +- .../graph-successors-absent/package.json | 2 +- .../graph-successors-absent/provenance.json | 2 +- .../rust-std/graph-successors/package.json | 2 +- .../rust-std/graph-successors/provenance.json | 2 +- .../graph-topological-cycle/package.json | 2 +- .../graph-topological-cycle/provenance.json | 2 +- .../rust-std/graph-topological/package.json | 2 +- .../graph-topological/provenance.json | 2 +- .../rust/rust-std/int-arithmetic/package.json | 2 +- .../rust-std/int-arithmetic/provenance.json | 2 +- .../rust-std/int-overflow-mul/package.json | 2 +- .../rust-std/int-overflow-mul/provenance.json | 2 +- .../rust-std/int-overflow-neg/package.json | 2 +- .../rust-std/int-overflow-neg/provenance.json | 2 +- .../rust-std/int-overflow-quot/package.json | 2 +- .../int-overflow-quot/provenance.json | 2 +- .../rust-std/int-overflow-sub/package.json | 2 +- .../rust-std/int-overflow-sub/provenance.json | 2 +- .../iterate-until-bounded/package.json | 2 +- .../iterate-until-bounded/provenance.json | 2 +- .../rust/rust-std/iterate-until/package.json | 2 +- .../rust-std/iterate-until/provenance.json | 2 +- compiler/rust/rust-std/iterate/package.json | 2 +- .../rust/rust-std/iterate/provenance.json | 2 +- .../rust-std/list-append-long/package.json | 2 +- .../rust-std/list-append-long/provenance.json | 2 +- compiler/rust/rust-std/list-fold/package.json | 2 +- .../rust/rust-std/list-fold/provenance.json | 2 +- .../rust/rust-std/lists-borrowed/package.json | 2 +- .../rust-std/lists-borrowed/provenance.json | 2 +- compiler/rust/rust-std/lists/package.json | 2 +- compiler/rust/rust-std/lists/provenance.json | 2 +- compiler/rust/rust-std/literals/package.json | 2 +- .../rust/rust-std/literals/provenance.json | 2 +- .../rust/rust-std/map-contains/package.json | 2 +- .../rust-std/map-contains/provenance.json | 2 +- compiler/rust/rust-std/map-fold/package.json | 2 +- .../rust/rust-std/map-fold/provenance.json | 2 +- .../rust-std/map-insert-last/package.json | 2 +- .../rust-std/map-insert-last/provenance.json | 2 +- .../rust-std/map-insert-replace/package.json | 2 +- .../map-insert-replace/provenance.json | 2 +- .../rust/rust-std/map-insert/package.json | 2 +- .../rust/rust-std/map-insert/provenance.json | 2 +- compiler/rust/rust-std/map-keys/package.json | 2 +- .../rust/rust-std/map-keys/provenance.json | 2 +- .../rust-std/map-lookup-absent/package.json | 2 +- .../map-lookup-absent/provenance.json | 2 +- .../rust/rust-std/map-lookup/package.json | 2 +- .../rust/rust-std/map-lookup/provenance.json | 2 +- .../rust-std/map-remove-absent/package.json | 2 +- .../map-remove-absent/provenance.json | 2 +- .../rust/rust-std/map-remove/package.json | 2 +- .../rust/rust-std/map-remove/provenance.json | 2 +- .../rust/rust-std/map-values/package.json | 2 +- .../rust/rust-std/map-values/provenance.json | 2 +- .../rust/rust-std/match-shapes/package.json | 2 +- .../rust-std/match-shapes/provenance.json | 2 +- .../rust/rust-std/nat-arithmetic/package.json | 2 +- .../rust-std/nat-arithmetic/provenance.json | 2 +- .../rust-std/nat-overflow-add/package.json | 2 +- .../rust-std/nat-overflow-add/provenance.json | 2 +- .../rust-std/nat-overflow-mul/package.json | 2 +- .../rust-std/nat-overflow-mul/provenance.json | 2 +- .../rust-std/nat-overflow-nested/package.json | 2 +- .../nat-overflow-nested/provenance.json | 2 +- .../rust-std/nat-overflow-succ/package.json | 2 +- .../nat-overflow-succ/provenance.json | 2 +- compiler/rust/rust-std/ordering/package.json | 2 +- .../rust/rust-std/ordering/provenance.json | 2 +- .../rust-std/pair-and-list-match/package.json | 2 +- .../pair-and-list-match/provenance.json | 2 +- .../rust-std/reasoning-dose-120/package.json | 2 +- .../reasoning-dose-120/provenance.json | 2 +- .../rust-std/reasoning-dose-60/package.json | 2 +- .../reasoning-dose-60/provenance.json | 2 +- .../rust-std/reasoning-gnaf-goal/package.json | 2 +- .../reasoning-gnaf-goal/provenance.json | 2 +- .../reasoning-gnaf-priority/package.json | 2 +- .../reasoning-gnaf-priority/provenance.json | 2 +- .../reasoning-gnaf-sweep/package.json | 2 +- .../reasoning-gnaf-sweep/provenance.json | 2 +- .../reasoning-grade-shock/package.json | 2 +- .../reasoning-grade-shock/provenance.json | 2 +- .../reasoning-grade-well/package.json | 2 +- .../reasoning-grade-well/provenance.json | 2 +- .../rust-std/reasoning-plan-2/package.json | 2 +- .../rust-std/reasoning-plan-2/provenance.json | 2 +- .../rust-std/reasoning-plan-5/package.json | 2 +- .../rust-std/reasoning-plan-5/provenance.json | 2 +- .../reasoning-review-exhausted/package.json | 2 +- .../provenance.json | 2 +- .../reasoning-review-rejected/package.json | 2 +- .../reasoning-review-rejected/provenance.json | 2 +- .../rust-std/reasoning-screen-0/package.json | 2 +- .../reasoning-screen-0/provenance.json | 2 +- .../reasoning-screen-100/package.json | 2 +- .../reasoning-screen-100/provenance.json | 2 +- .../rust-std/reasoning-screen-60/package.json | 2 +- .../reasoning-screen-60/provenance.json | 2 +- .../rust-std/reasoning-spend-2/package.json | 2 +- .../reasoning-spend-2/provenance.json | 2 +- .../reasoning-triage-shock/package.json | 2 +- .../reasoning-triage-shock/provenance.json | 2 +- .../reasoning-triage-traced/package.json | 2 +- .../reasoning-triage-traced/provenance.json | 2 +- .../reasoning-triage-well/package.json | 2 +- .../reasoning-triage-well/provenance.json | 2 +- .../rust/rust-std/record-fields/package.json | 2 +- .../rust-std/record-fields/provenance.json | 2 +- .../rust-std/set-contains-absent/package.json | 2 +- .../set-contains-absent/provenance.json | 2 +- .../rust/rust-std/set-contains/package.json | 2 +- .../rust-std/set-contains/provenance.json | 2 +- .../rust/rust-std/set-difference/package.json | 2 +- .../rust-std/set-difference/provenance.json | 2 +- compiler/rust/rust-std/set-fold/package.json | 2 +- .../rust/rust-std/set-fold/provenance.json | 2 +- .../rust-std/set-insert-bool/package.json | 2 +- .../rust-std/set-insert-bool/provenance.json | 2 +- .../rust/rust-std/set-insert-int/package.json | 2 +- .../rust-std/set-insert-int/provenance.json | 2 +- .../rust-std/set-insert-int8/package.json | 2 +- .../rust-std/set-insert-int8/provenance.json | 2 +- .../rust/rust-std/set-insert-nat/package.json | 2 +- .../rust-std/set-insert-nat/provenance.json | 2 +- .../rust-std/set-insert-product/package.json | 2 +- .../set-insert-product/provenance.json | 2 +- .../rust-std/set-insert-string/package.json | 2 +- .../set-insert-string/provenance.json | 2 +- .../rust-std/set-intersection/package.json | 2 +- .../rust-std/set-intersection/provenance.json | 2 +- .../rust-std/set-remove-absent/package.json | 2 +- .../set-remove-absent/provenance.json | 2 +- .../rust/rust-std/set-remove/package.json | 2 +- .../rust/rust-std/set-remove/provenance.json | 2 +- compiler/rust/rust-std/set-union/package.json | 2 +- .../rust/rust-std/set-union/provenance.json | 2 +- .../rust/rust-std/split-and-join/package.json | 2 +- .../rust-std/split-and-join/provenance.json | 2 +- .../rust/rust-std/string-escapes/package.json | 2 +- .../rust-std/string-escapes/provenance.json | 2 +- .../rust-std/sum-to-exhausted/package.json | 2 +- .../rust-std/sum-to-exhausted/provenance.json | 2 +- compiler/rust/rust-std/sum-to/package.json | 2 +- compiler/rust/rust-std/sum-to/provenance.json | 2 +- .../rust/rust-std/unit-closures/package.json | 2 +- .../rust-std/unit-closures/provenance.json | 2 +- .../rust/rust-std/unit-values/package.json | 2 +- .../rust/rust-std/unit-values/provenance.json | 2 +- .../rust/rust-std/wide-shapes/package.json | 2 +- .../rust/rust-std/wide-shapes/provenance.json | 2 +- .../collections/expected/build/manifest.json | 2 +- .../build/maps/Collections/Main.map.json | 2 +- .../build/maps/Collections/Measure.map.json | 2 +- .../build/maps/Collections/Tables.map.json | 2 +- ...086f47af2c0608b2e13.Collections.Main.lean} | 0 ...2c0608b2e13.Collections.Main.process.json} | 2 +- ...f47af2c0608b2e13.Collections.Measure.lean} | 0 ...608b2e13.Collections.Measure.process.json} | 2 +- ...6f47af2c0608b2e13.Collections.Tables.lean} | 0 ...0608b2e13.Collections.Tables.process.json} | 2 +- ...0608b2e13.LexLeanRuntime.Collections.lean} | 0 ...3.LexLeanRuntime.Collections.process.json} | 2 +- ...f2c0608b2e13.LexLeanRuntime.Portable.lean} | 0 ...2e13.LexLeanRuntime.Portable.process.json} | 2 +- ...be.P0f6d359d50d0d086f47af2c0608b2e13.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/collections/lexlean.lock | 2 +- .../fold-laws/expected/build/manifest.json | 2 +- .../build/maps/FoldLaws/Folds.map.json | 2 +- .../build/maps/FoldLaws/Kernels.map.json | 2 +- .../build/maps/FoldLaws/Main.map.json | 2 +- ...9f4c2cea21d972760d780.FoldLaws.Folds.lean} | 0 ...21d972760d780.FoldLaws.Folds.process.json} | 2 +- ...4c2cea21d972760d780.FoldLaws.Kernels.lean} | 0 ...d972760d780.FoldLaws.Kernels.process.json} | 2 +- ...c9f4c2cea21d972760d780.FoldLaws.Main.lean} | 0 ...a21d972760d780.FoldLaws.Main.process.json} | 2 +- ...72760d780.LexLeanRuntime.Collections.lean} | 0 ...0.LexLeanRuntime.Collections.process.json} | 2 +- ...cea21d972760d780.LexLeanRuntime.Laws.lean} | 0 ...2760d780.LexLeanRuntime.Laws.process.json} | 2 +- ...1d972760d780.LexLeanRuntime.Portable.lean} | 0 ...d780.LexLeanRuntime.Portable.process.json} | 2 +- ...be.P1d59f84598c9f4c2cea21d972760d780.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/fold-laws/lexlean.lock | 2 +- .../higher-order/expected/build/manifest.json | 2 +- .../maps/HigherOrder/Combinators.map.json | 2 +- .../build/maps/HigherOrder/Main.map.json | 2 +- ...0f05d9678db7.HigherOrder.Combinators.lean} | 0 ...8db7.HigherOrder.Combinators.process.json} | 2 +- ...cda9eec0f05d9678db7.HigherOrder.Main.lean} | 0 ...f05d9678db7.HigherOrder.Main.process.json} | 2 +- ...be.Pb5934bc97e423cda9eec0f05d9678db7.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/higher-order/lexlean.lock | 2 +- .../language-1.2/expected/build/manifest.json | 2 +- .../build/maps/LanguageTwelve/Main.map.json | 2 +- ...631d3fdfeeada166.LanguageTwelve.Main.lean} | 0 ...eeada166.LanguageTwelve.Main.process.json} | 2 +- ...be.P8f90c02b42edd596631d3fdfeeada166.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/language-1.2/lexlean.lock | 2 +- examples/models/expected/build/manifest.json | 2 +- .../expected/build/maps/Models/Flows.map.json | 2 +- .../build/maps/Models/Glyphs.map.json | 2 +- .../build/maps/Models/Ledger.map.json | 2 +- .../expected/build/maps/Models/Main.map.json | 2 +- .../build/maps/Models/Pipeline.map.json | 2 +- .../build/maps/Models/Policy.map.json | 2 +- .../build/maps/Models/Recognizer.map.json | 2 +- .../build/maps/Models/Session.map.json | 2 +- .../build/maps/Models/Triage.map.json | 2 +- ...e374148ef.LexLeanRuntime.Collections.lean} | 0 ...f.LexLeanRuntime.Collections.process.json} | 2 +- ...28d6c72e374148ef.LexLeanRuntime.Laws.lean} | 0 ...374148ef.LexLeanRuntime.Laws.process.json} | 2 +- ...d6c72e374148ef.LexLeanRuntime.Models.lean} | 0 ...4148ef.LexLeanRuntime.Models.process.json} | 2 +- ...c72e374148ef.LexLeanRuntime.Portable.lean} | 0 ...48ef.LexLeanRuntime.Portable.process.json} | 2 +- ...fd6f60128d6c72e374148ef.Models.Flows.lean} | 0 ...8d6c72e374148ef.Models.Flows.process.json} | 2 +- ...d6f60128d6c72e374148ef.Models.Glyphs.lean} | 0 ...d6c72e374148ef.Models.Glyphs.process.json} | 2 +- ...d6f60128d6c72e374148ef.Models.Ledger.lean} | 0 ...d6c72e374148ef.Models.Ledger.process.json} | 2 +- ...cfd6f60128d6c72e374148ef.Models.Main.lean} | 0 ...28d6c72e374148ef.Models.Main.process.json} | 2 +- ...f60128d6c72e374148ef.Models.Pipeline.lean} | 0 ...c72e374148ef.Models.Pipeline.process.json} | 2 +- ...d6f60128d6c72e374148ef.Models.Policy.lean} | 0 ...d6c72e374148ef.Models.Policy.process.json} | 2 +- ...0128d6c72e374148ef.Models.Recognizer.lean} | 0 ...2e374148ef.Models.Recognizer.process.json} | 2 +- ...6f60128d6c72e374148ef.Models.Session.lean} | 0 ...6c72e374148ef.Models.Session.process.json} | 2 +- ...d6f60128d6c72e374148ef.Models.Triage.lean} | 0 ...d6c72e374148ef.Models.Triage.process.json} | 2 +- ...ct.X91b57d30cfd6f60128d6c72e374148ef.lean} | 0 .../expected/verify/extract/process.json | 2 +- .../R0.lean | 4 +- .../R0/Compose/RustStd.lex.tex | 32 +- .../R0/RustStd.lean | 4 +- .../R1.lean | 4 +- .../R1/Compose/RustStd.lex.tex | 32 +- .../R1/RustStd.lean | 4 +- .../R2.lean | 4 +- .../R2/Compose/RustStd.lex.tex | 38 +-- .../R2/RustStd.lean | 4 +- .../R3.lean | 4 +- .../R3/Compose/RustStd.lex.tex | 30 +- .../R3/RustStd.lean | 4 +- .../R4.lean | 4 +- .../R4/Compose/RustStd.lex.tex | 32 +- .../R4/RustStd.lean | 4 +- .../R5.lean | 4 +- .../R5/Compose/RustStd.lex.tex | 24 +- .../R5/RustStd.lean | 4 +- .../R6.lean | 4 +- .../R6/Compose/RustStd.lex.tex | 24 +- .../R6/RustStd.lean | 4 +- .../R7.lean | 4 +- .../R7/Compose/RustStd.lex.tex | 24 +- .../R7/RustStd.lean | 4 +- .../R8.lean | 4 +- .../R8/Compose/RustStd.lex.tex | 24 +- .../R8/RustStd.lean | 4 +- .../models/expected/verify/preserve/audit.txt | 66 ++-- .../verify/preserve/preservation.json | 2 +- ...be.P91b57d30cfd6f60128d6c72e374148ef.lean} | 0 .../models/expected/verify/probe/process.json | 2 +- ...2e918bdc2f8a44a66473c4435e.R0.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R0.json | 1 - ...2e918bdc2f8a44a66473c4435e.R1.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R1.json | 1 - ...2e918bdc2f8a44a66473c4435e.R2.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R2.json | 1 - ...2e918bdc2f8a44a66473c4435e.R3.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R3.json | 1 - ...2f8a44a66473c4435e.R4.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R4.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R4.json | 1 - ...2f8a44a66473c4435e.R5.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R5.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R5.json | 1 - ...2f8a44a66473c4435e.R6.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R6.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R6.json | 1 - ...2f8a44a66473c4435e.R7.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R7.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R7.json | 1 - ...2f8a44a66473c4435e.R8.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R8.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R8.json | 1 - ...128d6c72e374148ef.R0.Compose.RustStd.json} | 2 +- ...30cfd6f60128d6c72e374148ef.R0.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R0.json | 1 + ...128d6c72e374148ef.R1.Compose.RustStd.json} | 2 +- ...30cfd6f60128d6c72e374148ef.R1.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R1.json | 1 + ...128d6c72e374148ef.R2.Compose.RustStd.json} | 2 +- ...30cfd6f60128d6c72e374148ef.R2.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R2.json | 1 + ...128d6c72e374148ef.R3.Compose.RustStd.json} | 2 +- ...30cfd6f60128d6c72e374148ef.R3.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R3.json | 1 + ...0128d6c72e374148ef.R4.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R4.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R4.json | 1 + ...0128d6c72e374148ef.R5.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R5.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R5.json | 1 + ...0128d6c72e374148ef.R6.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R6.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R6.json | 1 + ...0128d6c72e374148ef.R7.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R7.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R7.json | 1 + ...0128d6c72e374148ef.R8.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R8.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R8.json | 1 + .../preserve/LexLeanPreserve.Audit.json | 2 +- ....C49cf062e918bdc2f8a44a66473c4435e.R0.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R1.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R2.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R3.json | 1 - ...2f8a44a66473c4435e.R4.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R4.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R4.json | 1 - ...2f8a44a66473c4435e.R5.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R5.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R5.json | 1 - ...2f8a44a66473c4435e.R6.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R6.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R6.json | 1 - ...2f8a44a66473c4435e.R7.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R7.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R7.json | 1 - ...2f8a44a66473c4435e.R8.Compose.RustStd.json | 1 - ...2e918bdc2f8a44a66473c4435e.R8.RustStd.json | 1 - ....C49cf062e918bdc2f8a44a66473c4435e.R8.json | 1 - ...128d6c72e374148ef.R0.Compose.RustStd.json} | 2 +- ...0cfd6f60128d6c72e374148ef.R0.RustStd.json} | 2 +- ....C91b57d30cfd6f60128d6c72e374148ef.R0.json | 1 + ...128d6c72e374148ef.R1.Compose.RustStd.json} | 2 +- ...0cfd6f60128d6c72e374148ef.R1.RustStd.json} | 2 +- ....C91b57d30cfd6f60128d6c72e374148ef.R1.json | 1 + ...128d6c72e374148ef.R2.Compose.RustStd.json} | 2 +- ...0cfd6f60128d6c72e374148ef.R2.RustStd.json} | 2 +- ....C91b57d30cfd6f60128d6c72e374148ef.R2.json | 1 + ...128d6c72e374148ef.R3.Compose.RustStd.json} | 2 +- ...0cfd6f60128d6c72e374148ef.R3.RustStd.json} | 2 +- ....C91b57d30cfd6f60128d6c72e374148ef.R3.json | 1 + ...0128d6c72e374148ef.R4.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R4.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R4.json | 1 + ...0128d6c72e374148ef.R5.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R5.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R5.json | 1 + ...0128d6c72e374148ef.R6.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R6.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R6.json | 1 + ...0128d6c72e374148ef.R7.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R7.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R7.json | 1 + ...0128d6c72e374148ef.R8.Compose.RustStd.json | 1 + ...30cfd6f60128d6c72e374148ef.R8.RustStd.json | 1 + ....C91b57d30cfd6f60128d6c72e374148ef.R8.json | 1 + examples/models/lexlean.lock | 2 +- .../expected/build/manifest.json | 2 +- .../build/maps/Coverage/Boundary.map.json | 2 +- .../build/maps/Coverage/Colls.map.json | 2 +- .../build/maps/Coverage/Main.map.json | 2 +- .../build/maps/Coverage/Prims.map.json | 2 +- .../build/maps/Coverage/RecRoots.map.json | 2 +- .../build/maps/Coverage/Recur.map.json | 2 +- .../build/maps/Coverage/Syntax.map.json | 2 +- .../build/maps/Coverage/Types.map.json | 2 +- ...8ea11c4a7ac75c7962.Coverage.Boundary.lean} | 0 ...7ac75c7962.Coverage.Boundary.process.json} | 2 +- ...ac48ea11c4a7ac75c7962.Coverage.Colls.lean} | 0 ...c4a7ac75c7962.Coverage.Colls.process.json} | 2 +- ...aac48ea11c4a7ac75c7962.Coverage.Main.lean} | 0 ...1c4a7ac75c7962.Coverage.Main.process.json} | 2 +- ...ac48ea11c4a7ac75c7962.Coverage.Prims.lean} | 0 ...c4a7ac75c7962.Coverage.Prims.process.json} | 2 +- ...8ea11c4a7ac75c7962.Coverage.RecRoots.lean} | 0 ...7ac75c7962.Coverage.RecRoots.process.json} | 2 +- ...ac48ea11c4a7ac75c7962.Coverage.Recur.lean} | 0 ...c4a7ac75c7962.Coverage.Recur.process.json} | 2 +- ...c48ea11c4a7ac75c7962.Coverage.Syntax.lean} | 0 ...4a7ac75c7962.Coverage.Syntax.process.json} | 2 +- ...ac48ea11c4a7ac75c7962.Coverage.Types.lean} | 0 ...c4a7ac75c7962.Coverage.Types.process.json} | 2 +- ...ac75c7962.LexLeanRuntime.Collections.lean} | 0 ...2.LexLeanRuntime.Collections.process.json} | 2 +- ...a11c4a7ac75c7962.LexLeanRuntime.Laws.lean} | 0 ...c75c7962.LexLeanRuntime.Laws.process.json} | 2 +- ...4a7ac75c7962.LexLeanRuntime.Portable.lean} | 0 ...7962.LexLeanRuntime.Portable.process.json} | 2 +- ...ct.Xe05bf7cb47aac48ea11c4a7ac75c7962.lean} | 0 .../expected/verify/extract/process.json | 2 +- .../R0.lean | 22 +- .../R0/Compose/RustStd.lex.tex | 86 ++--- .../R0/RustStd.lean | 4 +- .../R1.lean | 22 +- .../R1/Compose/RustStd.lex.tex | 34 +- .../R1/RustStd.lean | 4 +- .../R10.lean | 4 +- .../R10/Compose/RustCore.lex.tex | 24 +- .../R10/Compose/RustStd.lex.tex | 24 +- .../R10/RustCore.lean | 4 +- .../R10/RustStd.lean | 4 +- .../R11.lean | 4 +- .../R11/Compose/RustCore.lex.tex | 24 +- .../R11/Compose/RustStd.lex.tex | 24 +- .../R11/RustCore.lean | 4 +- .../R11/RustStd.lean | 4 +- .../R12.lean | 4 +- .../R12/Compose/RustCore.lex.tex | 30 +- .../R12/Compose/RustStd.lex.tex | 30 +- .../R12/RustCore.lean | 4 +- .../R12/RustStd.lean | 4 +- .../R13.lean | 4 +- .../R13/Compose/RustStd.lex.tex | 30 +- .../R13/RustStd.lean | 4 +- .../R14.lean | 4 +- .../R14/Compose/RustCore.lex.tex | 42 +-- .../R14/Compose/RustStd.lex.tex | 42 +-- .../R14/RustCore.lean | 4 +- .../R14/RustStd.lean | 4 +- .../R15.lean | 4 +- .../R15/Compose/RustCore.lex.tex | 24 +- .../R15/Compose/RustStd.lex.tex | 24 +- .../R15/RustCore.lean | 4 +- .../R15/RustStd.lean | 4 +- .../R16.lean | 4 +- .../R16/Compose/RustCore.lex.tex | 24 +- .../R16/Compose/RustStd.lex.tex | 24 +- .../R16/RustCore.lean | 4 +- .../R16/RustStd.lean | 4 +- .../R17.lean | 4 +- .../R17/Compose/RustCore.lex.tex | 24 +- .../R17/Compose/RustStd.lex.tex | 24 +- .../R17/RustCore.lean | 4 +- .../R17/RustStd.lean | 4 +- .../R18.lean | 4 +- .../R18/Compose/RustCore.lex.tex | 24 +- .../R18/Compose/RustStd.lex.tex | 24 +- .../R18/RustCore.lean | 4 +- .../R18/RustStd.lean | 4 +- .../R19.lean | 4 +- .../R19/Compose/RustStd.lex.tex | 24 +- .../R19/RustStd.lean | 4 +- .../R2.lean | 22 +- .../R2/Compose/RustStd.lex.tex | 34 +- .../R2/RustStd.lean | 4 +- .../R20.lean | 4 +- .../R20/Compose/RustCore.lex.tex | 24 +- .../R20/Compose/RustStd.lex.tex | 24 +- .../R20/RustCore.lean | 4 +- .../R20/RustStd.lean | 4 +- .../R21.lean | 4 +- .../R21/Compose/RustCore.lex.tex | 24 +- .../R21/Compose/RustStd.lex.tex | 24 +- .../R21/RustCore.lean | 4 +- .../R21/RustStd.lean | 4 +- .../R22.lean | 4 +- .../R22/Compose/RustCore.lex.tex | 24 +- .../R22/Compose/RustStd.lex.tex | 24 +- .../R22/RustCore.lean | 4 +- .../R22/RustStd.lean | 4 +- .../R23.lean | 4 +- .../R23/Compose/RustCore.lex.tex | 24 +- .../R23/Compose/RustStd.lex.tex | 24 +- .../R23/RustCore.lean | 4 +- .../R23/RustStd.lean | 4 +- .../R24.lean | 4 +- .../R24/Compose/RustCore.lex.tex | 24 +- .../R24/Compose/RustStd.lex.tex | 24 +- .../R24/RustCore.lean | 4 +- .../R24/RustStd.lean | 4 +- .../R25.lean | 4 +- .../R25/Compose/RustCore.lex.tex | 24 +- .../R25/Compose/RustStd.lex.tex | 24 +- .../R25/RustCore.lean | 4 +- .../R25/RustStd.lean | 4 +- .../R26.lean | 4 +- .../R26/Compose/RustStd.lex.tex | 24 +- .../R26/RustStd.lean | 4 +- .../R27.lean | 4 +- .../R27/Compose/RustStd.lex.tex | 24 +- .../R27/RustStd.lean | 4 +- .../R28.lean | 4 +- .../R28/Compose/RustStd.lex.tex | 24 +- .../R28/RustStd.lean | 4 +- .../R29.lean | 4 +- .../R29/Compose/RustStd.lex.tex | 24 +- .../R29/RustStd.lean | 4 +- .../R3.lean | 22 +- .../R3/Compose/RustStd.lex.tex | 34 +- .../R3/RustStd.lean | 4 +- .../R30.lean | 4 +- .../R30/Compose/RustStd.lex.tex | 38 +-- .../R30/RustStd.lean | 4 +- .../R31.lean | 4 +- .../R31/Compose/RustStd.lex.tex | 46 +-- .../R31/RustStd.lean | 4 +- .../R32.lean | 4 +- .../R32/Compose/RustCore.lex.tex | 24 +- .../R32/Compose/RustStd.lex.tex | 24 +- .../R32/RustCore.lean | 4 +- .../R32/RustStd.lean | 4 +- .../R33.lean | 4 +- .../R33/Compose/RustStd.lex.tex | 32 +- .../R33/RustStd.lean | 4 +- .../R4.lean | 22 +- .../R4/Compose/RustStd.lex.tex | 34 +- .../R4/RustStd.lean | 4 +- .../R5.lean | 4 +- .../R5/Compose/RustStd.lex.tex | 24 +- .../R5/RustStd.lean | 4 +- .../R6.lean | 22 +- .../R6/Compose/RustStd.lex.tex | 34 +- .../R6/RustStd.lean | 4 +- .../R7.lean | 22 +- .../R7/Compose/RustStd.lex.tex | 34 +- .../R7/RustStd.lean | 4 +- .../R8.lean | 22 +- .../R8/Compose/RustStd.lex.tex | 34 +- .../R8/RustStd.lean | 4 +- .../R9.lean | 4 +- .../R9/Compose/RustStd.lex.tex | 24 +- .../R9/RustStd.lean | 4 +- .../expected/verify/preserve/audit.txt | 308 +++++++++--------- .../verify/preserve/preservation.json | 2 +- ...be.Pe05bf7cb47aac48ea11c4a7ac75c7962.lean} | 0 .../expected/verify/probe/process.json | 2 +- ...8ea11c4a7ac75c7962.R0.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R0.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json | 1 + ...8ea11c4a7ac75c7962.R1.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R1.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json | 1 + ...11c4a7ac75c7962.R10.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R10.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R10.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R10.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json | 1 + ...11c4a7ac75c7962.R11.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R11.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R11.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R11.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json | 1 + ...11c4a7ac75c7962.R12.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R12.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R12.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R12.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json | 1 + ...a11c4a7ac75c7962.R13.Compose.RustStd.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R13.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json | 1 + ...11c4a7ac75c7962.R14.Compose.RustCore.json} | 2 +- ...ea11c4a7ac75c7962.R14.Compose.RustStd.json | 1 + ...7aac48ea11c4a7ac75c7962.R14.RustCore.json} | 2 +- ...b47aac48ea11c4a7ac75c7962.R14.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json | 1 + ...a11c4a7ac75c7962.R15.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R15.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R15.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R15.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json | 1 + ...a11c4a7ac75c7962.R16.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R16.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R16.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R16.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json | 1 + ...a11c4a7ac75c7962.R17.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R17.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R17.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R17.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json | 1 + ...a11c4a7ac75c7962.R18.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R18.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R18.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R18.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json | 1 + ...ea11c4a7ac75c7962.R19.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R19.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json | 1 + ...8ea11c4a7ac75c7962.R2.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R2.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json | 1 + ...a11c4a7ac75c7962.R20.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R20.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R20.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R20.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json | 1 + ...a11c4a7ac75c7962.R21.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R21.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R21.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R21.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json | 1 + ...a11c4a7ac75c7962.R22.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R22.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R22.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R22.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json | 1 + ...a11c4a7ac75c7962.R23.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R23.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R23.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R23.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json | 1 + ...a11c4a7ac75c7962.R24.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R24.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R24.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R24.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json | 1 + ...a11c4a7ac75c7962.R25.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R25.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R25.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R25.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json | 1 + ...ea11c4a7ac75c7962.R26.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R26.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json | 1 + ...ea11c4a7ac75c7962.R27.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R27.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json | 1 + ...ea11c4a7ac75c7962.R28.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R28.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json | 1 + ...ea11c4a7ac75c7962.R29.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R29.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json | 1 + ...8ea11c4a7ac75c7962.R3.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R3.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json | 1 + ...ea11c4a7ac75c7962.R30.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R30.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json | 1 + ...ea11c4a7ac75c7962.R31.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R31.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json | 1 + ...a11c4a7ac75c7962.R32.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R32.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R32.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R32.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json | 1 + ...ea11c4a7ac75c7962.R33.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R33.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json | 1 + ...8ea11c4a7ac75c7962.R4.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R4.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json | 1 + ...8ea11c4a7ac75c7962.R5.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R5.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json | 1 + ...8ea11c4a7ac75c7962.R6.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R6.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json | 1 + ...8ea11c4a7ac75c7962.R7.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R7.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json | 1 + ...8ea11c4a7ac75c7962.R8.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R8.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json | 1 + ...8ea11c4a7ac75c7962.R9.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R9.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json | 1 + ...62b7601d32507ebc3a.R0.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R0.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R0.json | 1 - ...62b7601d32507ebc3a.R1.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R1.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R1.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R10.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R11.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R12.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R13.json | 1 - ...2b7601d32507ebc3a.R14.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R14.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R14.json | 1 - ...b7601d32507ebc3a.R15.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R15.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R15.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R15.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R15.json | 1 - ...b7601d32507ebc3a.R16.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R16.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R16.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R16.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R16.json | 1 - ...b7601d32507ebc3a.R17.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R17.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R17.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R17.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R17.json | 1 - ...b7601d32507ebc3a.R18.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R18.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R18.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R18.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R18.json | 1 - ...2b7601d32507ebc3a.R19.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R19.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R19.json | 1 - ...62b7601d32507ebc3a.R2.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R2.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R2.json | 1 - ...b7601d32507ebc3a.R20.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R20.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R20.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R20.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R20.json | 1 - ...b7601d32507ebc3a.R21.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R21.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R21.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R21.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R21.json | 1 - ...b7601d32507ebc3a.R22.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R22.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R22.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R22.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R22.json | 1 - ...b7601d32507ebc3a.R23.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R23.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R23.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R23.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R23.json | 1 - ...b7601d32507ebc3a.R24.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R24.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R24.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R24.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R24.json | 1 - ...b7601d32507ebc3a.R25.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R25.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R25.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R25.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R25.json | 1 - ...2b7601d32507ebc3a.R26.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R26.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R26.json | 1 - ...2b7601d32507ebc3a.R27.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R27.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R27.json | 1 - ...2b7601d32507ebc3a.R28.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R28.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R28.json | 1 - ...2b7601d32507ebc3a.R29.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R29.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R29.json | 1 - ...62b7601d32507ebc3a.R3.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R3.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R3.json | 1 - ...2b7601d32507ebc3a.R30.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R30.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R30.json | 1 - ...2b7601d32507ebc3a.R31.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R31.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R31.json | 1 - ...b7601d32507ebc3a.R32.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R32.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R32.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R32.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R32.json | 1 - ...2b7601d32507ebc3a.R33.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R33.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R33.json | 1 - ...62b7601d32507ebc3a.R4.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R4.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R4.json | 1 - ...62b7601d32507ebc3a.R5.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R5.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R5.json | 1 - ...62b7601d32507ebc3a.R6.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R6.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R6.json | 1 - ...62b7601d32507ebc3a.R7.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R7.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R7.json | 1 - ...62b7601d32507ebc3a.R8.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R8.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R8.json | 1 - ...62b7601d32507ebc3a.R9.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R9.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R9.json | 1 - .../preserve/LexLeanPreserve.Audit.json | 2 +- ...8ea11c4a7ac75c7962.R0.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R0.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json | 1 + ...8ea11c4a7ac75c7962.R1.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R1.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json | 1 + ...11c4a7ac75c7962.R10.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R10.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R10.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R10.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json | 1 + ...11c4a7ac75c7962.R11.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R11.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R11.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R11.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json | 1 + ...11c4a7ac75c7962.R12.Compose.RustCore.json} | 2 +- ...a11c4a7ac75c7962.R12.Compose.RustStd.json} | 2 +- ...7aac48ea11c4a7ac75c7962.R12.RustCore.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R12.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json | 1 + ...a11c4a7ac75c7962.R13.Compose.RustStd.json} | 2 +- ...47aac48ea11c4a7ac75c7962.R13.RustStd.json} | 2 +- ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json | 1 + ...11c4a7ac75c7962.R14.Compose.RustCore.json} | 2 +- ...ea11c4a7ac75c7962.R14.Compose.RustStd.json | 1 + ...7aac48ea11c4a7ac75c7962.R14.RustCore.json} | 2 +- ...b47aac48ea11c4a7ac75c7962.R14.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json | 1 + ...a11c4a7ac75c7962.R15.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R15.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R15.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R15.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json | 1 + ...a11c4a7ac75c7962.R16.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R16.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R16.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R16.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json | 1 + ...a11c4a7ac75c7962.R17.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R17.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R17.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R17.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json | 1 + ...a11c4a7ac75c7962.R18.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R18.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R18.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R18.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json | 1 + ...ea11c4a7ac75c7962.R19.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R19.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json | 1 + ...8ea11c4a7ac75c7962.R2.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R2.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json | 1 + ...a11c4a7ac75c7962.R20.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R20.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R20.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R20.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json | 1 + ...a11c4a7ac75c7962.R21.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R21.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R21.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R21.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json | 1 + ...a11c4a7ac75c7962.R22.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R22.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R22.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R22.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json | 1 + ...a11c4a7ac75c7962.R23.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R23.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R23.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R23.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json | 1 + ...a11c4a7ac75c7962.R24.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R24.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R24.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R24.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json | 1 + ...a11c4a7ac75c7962.R25.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R25.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R25.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R25.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json | 1 + ...ea11c4a7ac75c7962.R26.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R26.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json | 1 + ...ea11c4a7ac75c7962.R27.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R27.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json | 1 + ...ea11c4a7ac75c7962.R28.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R28.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json | 1 + ...ea11c4a7ac75c7962.R29.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R29.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json | 1 + ...8ea11c4a7ac75c7962.R3.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R3.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json | 1 + ...ea11c4a7ac75c7962.R30.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R30.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json | 1 + ...a11c4a7ac75c7962.R31.Compose.RustStd.json} | 2 +- ...b47aac48ea11c4a7ac75c7962.R31.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json | 1 + ...a11c4a7ac75c7962.R32.Compose.RustCore.json | 1 + ...ea11c4a7ac75c7962.R32.Compose.RustStd.json | 1 + ...47aac48ea11c4a7ac75c7962.R32.RustCore.json | 1 + ...b47aac48ea11c4a7ac75c7962.R32.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json | 1 + ...ea11c4a7ac75c7962.R33.Compose.RustStd.json | 1 + ...b47aac48ea11c4a7ac75c7962.R33.RustStd.json | 1 + ...Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json | 1 + ...8ea11c4a7ac75c7962.R4.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R4.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json | 1 + ...8ea11c4a7ac75c7962.R5.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R5.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json | 1 + ...8ea11c4a7ac75c7962.R6.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R6.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json | 1 + ...8ea11c4a7ac75c7962.R7.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R7.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json | 1 + ...8ea11c4a7ac75c7962.R8.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R8.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json | 1 + ...8ea11c4a7ac75c7962.R9.Compose.RustStd.json | 1 + ...cb47aac48ea11c4a7ac75c7962.R9.RustStd.json | 1 + ....Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json | 1 + ...62b7601d32507ebc3a.R0.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R0.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R0.json | 1 - ...62b7601d32507ebc3a.R1.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R1.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R1.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R10.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R11.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R12.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R13.json | 1 - ...2b7601d32507ebc3a.R14.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R14.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R14.json | 1 - ...b7601d32507ebc3a.R15.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R15.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R15.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R15.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R15.json | 1 - ...b7601d32507ebc3a.R16.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R16.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R16.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R16.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R16.json | 1 - ...b7601d32507ebc3a.R17.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R17.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R17.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R17.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R17.json | 1 - ...b7601d32507ebc3a.R18.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R18.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R18.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R18.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R18.json | 1 - ...2b7601d32507ebc3a.R19.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R19.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R19.json | 1 - ...62b7601d32507ebc3a.R2.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R2.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R2.json | 1 - ...b7601d32507ebc3a.R20.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R20.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R20.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R20.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R20.json | 1 - ...b7601d32507ebc3a.R21.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R21.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R21.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R21.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R21.json | 1 - ...b7601d32507ebc3a.R22.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R22.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R22.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R22.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R22.json | 1 - ...b7601d32507ebc3a.R23.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R23.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R23.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R23.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R23.json | 1 - ...b7601d32507ebc3a.R24.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R24.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R24.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R24.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R24.json | 1 - ...b7601d32507ebc3a.R25.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R25.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R25.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R25.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R25.json | 1 - ...3e36d5c62b7601d32507ebc3a.R26.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R26.json | 1 - ...2b7601d32507ebc3a.R27.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R27.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R27.json | 1 - ...2b7601d32507ebc3a.R28.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R28.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R28.json | 1 - ...2b7601d32507ebc3a.R29.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R29.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R29.json | 1 - ...62b7601d32507ebc3a.R3.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R3.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R3.json | 1 - ...2b7601d32507ebc3a.R30.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R30.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R30.json | 1 - ...2b7601d32507ebc3a.R31.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R31.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R31.json | 1 - ...b7601d32507ebc3a.R32.Compose.RustCore.json | 1 - ...2b7601d32507ebc3a.R32.Compose.RustStd.json | 1 - ...e36d5c62b7601d32507ebc3a.R32.RustCore.json | 1 - ...3e36d5c62b7601d32507ebc3a.R32.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R32.json | 1 - ...2b7601d32507ebc3a.R33.Compose.RustStd.json | 1 - ...3e36d5c62b7601d32507ebc3a.R33.RustStd.json | 1 - ...Cf3572b43e36d5c62b7601d32507ebc3a.R33.json | 1 - ...62b7601d32507ebc3a.R4.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R4.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R4.json | 1 - ...62b7601d32507ebc3a.R5.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R5.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R5.json | 1 - ...62b7601d32507ebc3a.R6.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R6.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R6.json | 1 - ...62b7601d32507ebc3a.R7.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R7.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R7.json | 1 - ...62b7601d32507ebc3a.R8.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R8.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R8.json | 1 - ...62b7601d32507ebc3a.R9.Compose.RustStd.json | 1 - ...43e36d5c62b7601d32507ebc3a.R9.RustStd.json | 1 - ....Cf3572b43e36d5c62b7601d32507ebc3a.R9.json | 1 - examples/production-coverage/lexlean.lock | 2 +- .../production/expected/build/manifest.json | 2 +- .../build/maps/Production/Kernel.map.json | 2 +- .../build/maps/Production/Main.map.json | 2 +- ...9d.LexLeanRuntime.Collections.process.json | 1 - ...2ce9d.LexLeanRuntime.Portable.process.json | 1 - ...6c51cc7c8.LexLeanRuntime.Collections.lean} | 0 ...c8.LexLeanRuntime.Collections.process.json | 1 + ...ded11826c51cc7c8.LexLeanRuntime.Laws.lean} | 0 ...c51cc7c8.LexLeanRuntime.Laws.process.json} | 2 +- ...1826c51cc7c8.LexLeanRuntime.Portable.lean} | 0 ...cc7c8.LexLeanRuntime.Portable.process.json | 1 + ...93ded11826c51cc7c8.Production.Kernel.lean} | 0 ...26c51cc7c8.Production.Kernel.process.json} | 2 +- ...8b93ded11826c51cc7c8.Production.Main.lean} | 0 ...1826c51cc7c8.Production.Main.process.json} | 2 +- ...ct.Xf5a58e441acc8b93ded11826c51cc7c8.lean} | 0 .../expected/verify/extract/process.json | 2 +- .../R0.lean | 4 +- .../R0/Compose/RustCore.lex.tex | 24 +- .../R0/Compose/RustStd.lex.tex | 24 +- .../R0/RustCore.lean | 4 +- .../R0/RustStd.lean | 4 +- .../R1.lean | 4 +- .../R1/Compose/RustCore.lex.tex | 30 +- .../R1/Compose/RustStd.lex.tex | 30 +- .../R1/RustCore.lean | 4 +- .../R1/RustStd.lean | 4 +- .../R2.lean | 4 +- .../R2/Compose/RustCore.lex.tex | 24 +- .../R2/Compose/RustStd.lex.tex | 24 +- .../R2/RustCore.lean | 4 +- .../R2/RustStd.lean | 4 +- .../R3.lean | 4 +- .../R3/Compose/RustCore.lex.tex | 24 +- .../R3/Compose/RustStd.lex.tex | 24 +- .../R3/RustCore.lean | 4 +- .../R3/RustStd.lean | 4 +- .../R4.lean | 4 +- .../R4/Compose/RustStd.lex.tex | 24 +- .../R4/RustStd.lean | 4 +- .../R5.lean | 4 +- .../R5/Compose/RustStd.lex.tex | 24 +- .../R5/RustStd.lean | 4 +- .../expected/verify/preserve/audit.txt | 56 ++-- .../verify/preserve/preservation.json | 2 +- ...be.Pf5a58e441acc8b93ded11826c51cc7c8.lean} | 0 .../expected/verify/probe/process.json | 2 +- ...618eff0bdc9a2ce9d.R0.Compose.RustCore.json | 1 - ...4618eff0bdc9a2ce9d.R0.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R0.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json | 1 - ...618eff0bdc9a2ce9d.R1.Compose.RustCore.json | 1 - ...4618eff0bdc9a2ce9d.R1.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R1.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json | 1 - ...618eff0bdc9a2ce9d.R2.Compose.RustCore.json | 1 - ...4618eff0bdc9a2ce9d.R2.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R2.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json | 1 - ...618eff0bdc9a2ce9d.R3.Compose.RustCore.json | 1 - ...4618eff0bdc9a2ce9d.R3.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R3.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json | 1 - ...4618eff0bdc9a2ce9d.R4.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R4.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json | 1 - ...4618eff0bdc9a2ce9d.R5.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R5.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json | 1 - ...3ded11826c51cc7c8.R0.Compose.RustCore.json | 1 + ...93ded11826c51cc7c8.R0.Compose.RustStd.json | 1 + ...1acc8b93ded11826c51cc7c8.R0.RustCore.json} | 2 +- ...441acc8b93ded11826c51cc7c8.R0.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R0.json | 1 + ...3ded11826c51cc7c8.R1.Compose.RustCore.json | 1 + ...93ded11826c51cc7c8.R1.Compose.RustStd.json | 1 + ...1acc8b93ded11826c51cc7c8.R1.RustCore.json} | 2 +- ...441acc8b93ded11826c51cc7c8.R1.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R1.json | 1 + ...3ded11826c51cc7c8.R2.Compose.RustCore.json | 1 + ...93ded11826c51cc7c8.R2.Compose.RustStd.json | 1 + ...1acc8b93ded11826c51cc7c8.R2.RustCore.json} | 2 +- ...441acc8b93ded11826c51cc7c8.R2.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R2.json | 1 + ...3ded11826c51cc7c8.R3.Compose.RustCore.json | 1 + ...93ded11826c51cc7c8.R3.Compose.RustStd.json | 1 + ...1acc8b93ded11826c51cc7c8.R3.RustCore.json} | 2 +- ...441acc8b93ded11826c51cc7c8.R3.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R3.json | 1 + ...93ded11826c51cc7c8.R4.Compose.RustStd.json | 1 + ...441acc8b93ded11826c51cc7c8.R4.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R4.json | 1 + ...93ded11826c51cc7c8.R5.Compose.RustStd.json | 1 + ...441acc8b93ded11826c51cc7c8.R5.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R5.json | 1 + .../preserve/LexLeanPreserve.Audit.json | 2 +- ...4618eff0bdc9a2ce9d.R0.Compose.RustStd.json | 1 - ...5f4e2844618eff0bdc9a2ce9d.R0.RustCore.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R0.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json | 1 - ...4618eff0bdc9a2ce9d.R1.Compose.RustStd.json | 1 - ...5f4e2844618eff0bdc9a2ce9d.R1.RustCore.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R1.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json | 1 - ...4618eff0bdc9a2ce9d.R2.Compose.RustStd.json | 1 - ...5f4e2844618eff0bdc9a2ce9d.R2.RustCore.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R2.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json | 1 - ...4618eff0bdc9a2ce9d.R3.Compose.RustStd.json | 1 - ...5f4e2844618eff0bdc9a2ce9d.R3.RustCore.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R3.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json | 1 - ...4618eff0bdc9a2ce9d.R4.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R4.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json | 1 - ...4618eff0bdc9a2ce9d.R5.Compose.RustStd.json | 1 - ...05f4e2844618eff0bdc9a2ce9d.R5.RustStd.json | 1 - ....Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json | 1 - ...ded11826c51cc7c8.R0.Compose.RustCore.json} | 2 +- ...93ded11826c51cc7c8.R0.Compose.RustStd.json | 1 + ...41acc8b93ded11826c51cc7c8.R0.RustCore.json | 1 + ...441acc8b93ded11826c51cc7c8.R0.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R0.json | 1 + ...ded11826c51cc7c8.R1.Compose.RustCore.json} | 2 +- ...93ded11826c51cc7c8.R1.Compose.RustStd.json | 1 + ...41acc8b93ded11826c51cc7c8.R1.RustCore.json | 1 + ...441acc8b93ded11826c51cc7c8.R1.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R1.json | 1 + ...ded11826c51cc7c8.R2.Compose.RustCore.json} | 2 +- ...93ded11826c51cc7c8.R2.Compose.RustStd.json | 1 + ...41acc8b93ded11826c51cc7c8.R2.RustCore.json | 1 + ...441acc8b93ded11826c51cc7c8.R2.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R2.json | 1 + ...ded11826c51cc7c8.R3.Compose.RustCore.json} | 2 +- ...93ded11826c51cc7c8.R3.Compose.RustStd.json | 1 + ...41acc8b93ded11826c51cc7c8.R3.RustCore.json | 1 + ...441acc8b93ded11826c51cc7c8.R3.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R3.json | 1 + ...93ded11826c51cc7c8.R4.Compose.RustStd.json | 1 + ...441acc8b93ded11826c51cc7c8.R4.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R4.json | 1 + ...93ded11826c51cc7c8.R5.Compose.RustStd.json | 1 + ...441acc8b93ded11826c51cc7c8.R5.RustStd.json | 1 + ....Cf5a58e441acc8b93ded11826c51cc7c8.R5.json | 1 + examples/production/lexlean.lock | 2 +- .../reasoning/expected/build/manifest.json | 2 +- .../build/maps/Reasoning/Budget.map.json | 2 +- .../build/maps/Reasoning/Clinic.map.json | 2 +- .../build/maps/Reasoning/Main.map.json | 2 +- .../build/maps/Reasoning/Planner.map.json | 2 +- .../build/maps/Reasoning/Screening.map.json | 2 +- ...f9b12c608.LexLeanRuntime.Collections.lean} | 0 ...08.LexLeanRuntime.Collections.process.json | 1 + ...6f91f78f9b12c608.LexLeanRuntime.Laws.lean} | 0 ...9b12c608.LexLeanRuntime.Laws.process.json} | 2 +- ...91f78f9b12c608.LexLeanRuntime.Models.lean} | 0 ...12c608.LexLeanRuntime.Models.process.json} | 2 +- ...f78f9b12c608.LexLeanRuntime.Portable.lean} | 0 ...2c608.LexLeanRuntime.Portable.process.json | 1 + ...78f9b12c608.LexLeanRuntime.Reasoning.lean} | 0 ...608.LexLeanRuntime.Reasoning.process.json} | 2 +- ...1ec6f91f78f9b12c608.Reasoning.Budget.lean} | 0 ...78f9b12c608.Reasoning.Budget.process.json} | 2 +- ...1ec6f91f78f9b12c608.Reasoning.Clinic.lean} | 0 ...78f9b12c608.Reasoning.Clinic.process.json} | 2 +- ...881ec6f91f78f9b12c608.Reasoning.Main.lean} | 0 ...1f78f9b12c608.Reasoning.Main.process.json} | 2 +- ...ec6f91f78f9b12c608.Reasoning.Planner.lean} | 0 ...8f9b12c608.Reasoning.Planner.process.json} | 2 +- ...6f91f78f9b12c608.Reasoning.Screening.lean} | 0 ...9b12c608.Reasoning.Screening.process.json} | 2 +- ...3f.LexLeanRuntime.Collections.process.json | 1 - ...310b65f3f.LexLeanRuntime.Laws.process.json | 1 - ...65f3f.LexLeanRuntime.Portable.process.json | 1 - ...ct.X02b315b69b8881ec6f91f78f9b12c608.lean} | 0 .../expected/verify/extract/process.json | 2 +- .../R0.lean | 4 +- .../R0/Compose/RustCore.lex.tex | 44 +-- .../R0/RustCore.lean | 4 +- .../R1.lean | 4 +- .../R1/Compose/RustCore.lex.tex | 44 +-- .../R1/RustCore.lean | 4 +- .../R2.lean | 4 +- .../R2/Compose/RustStd.lex.tex | 62 ++-- .../R2/RustStd.lean | 4 +- .../R3.lean | 4 +- .../R3/Compose/RustStd.lex.tex | 54 +-- .../R3/RustStd.lean | 4 +- .../R4.lean | 4 +- .../R4/Compose/RustStd.lex.tex | 38 +-- .../R4/RustStd.lean | 4 +- .../R5.lean | 4 +- .../R5/Compose/RustCore.lex.tex | 44 +-- .../R5/RustCore.lean | 4 +- .../R6.lean | 4 +- .../R6/Compose/RustStd.lex.tex | 54 +-- .../R6/RustStd.lean | 4 +- .../R7.lean | 4 +- .../R7/Compose/RustStd.lex.tex | 30 +- .../R7/RustStd.lean | 4 +- .../expected/verify/preserve/audit.txt | 98 +++--- .../verify/preserve/preservation.json | 2 +- ...be.P02b315b69b8881ec6f91f78f9b12c608.lean} | 0 .../expected/verify/probe/process.json | 2 +- ...c6f91f78f9b12c608.R0.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R0.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R0.json | 1 + ...c6f91f78f9b12c608.R1.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R1.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R1.json | 1 + ...ec6f91f78f9b12c608.R2.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R2.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R2.json | 1 + ...ec6f91f78f9b12c608.R3.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R3.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R3.json | 1 + ...ec6f91f78f9b12c608.R4.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R4.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R4.json | 1 + ...c6f91f78f9b12c608.R5.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R5.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R5.json | 1 + ...ec6f91f78f9b12c608.R6.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R6.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R6.json | 1 + ...ec6f91f78f9b12c608.R7.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R7.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R7.json | 1 + ...cfd69727310b65f3f.R0.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R0.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R0.json | 1 - ...cfd69727310b65f3f.R1.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R1.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R1.json | 1 - ...6cfd69727310b65f3f.R2.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R2.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R2.json | 1 - ...6cfd69727310b65f3f.R3.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R3.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R3.json | 1 - ...6cfd69727310b65f3f.R4.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R4.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R4.json | 1 - ...cfd69727310b65f3f.R5.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R5.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R5.json | 1 - ...6cfd69727310b65f3f.R6.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R6.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R6.json | 1 - ...6cfd69727310b65f3f.R7.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R7.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R7.json | 1 - .../preserve/LexLeanPreserve.Audit.json | 2 +- ...c6f91f78f9b12c608.R0.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R0.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R0.json | 1 + ...c6f91f78f9b12c608.R1.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R1.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R1.json | 1 + ...ec6f91f78f9b12c608.R2.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R2.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R2.json | 1 + ...ec6f91f78f9b12c608.R3.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R3.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R3.json | 1 + ...ec6f91f78f9b12c608.R4.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R4.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R4.json | 1 + ...c6f91f78f9b12c608.R5.Compose.RustCore.json | 1 + ...69b8881ec6f91f78f9b12c608.R5.RustCore.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R5.json | 1 + ...ec6f91f78f9b12c608.R6.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R6.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R6.json | 1 + ...ec6f91f78f9b12c608.R7.Compose.RustStd.json | 1 + ...b69b8881ec6f91f78f9b12c608.R7.RustStd.json | 1 + ....C02b315b69b8881ec6f91f78f9b12c608.R7.json | 1 + ...cfd69727310b65f3f.R0.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R0.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R0.json | 1 - ...cfd69727310b65f3f.R1.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R1.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R1.json | 1 - ...6cfd69727310b65f3f.R2.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R2.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R2.json | 1 - ...6cfd69727310b65f3f.R3.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R3.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R3.json | 1 - ...6cfd69727310b65f3f.R4.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R4.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R4.json | 1 - ...cfd69727310b65f3f.R5.Compose.RustCore.json | 1 - ...d681c076cfd69727310b65f3f.R5.RustCore.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R5.json | 1 - ...6cfd69727310b65f3f.R6.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R6.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R6.json | 1 - ...6cfd69727310b65f3f.R7.Compose.RustStd.json | 1 - ...8d681c076cfd69727310b65f3f.R7.RustStd.json | 1 - ....C7b45b58d681c076cfd69727310b65f3f.R7.json | 1 - examples/reasoning/lexlean.lock | 2 +- .../recursion/expected/build/manifest.json | 2 +- .../build/maps/Recursion/Main.map.json | 2 +- .../build/maps/Recursion/Syntax.map.json | 2 +- ...17ced36db.LexLeanRuntime.Collections.lean} | 0 ...db.LexLeanRuntime.Collections.process.json | 1 + ...7e0e1e617ced36db.LexLeanRuntime.Laws.lean} | 0 ...17ced36db.LexLeanRuntime.Laws.process.json | 1 + ...1e617ced36db.LexLeanRuntime.Portable.lean} | 0 ...d36db.LexLeanRuntime.Portable.process.json | 1 + ...d8adb7e0e1e617ced36db.Recursion.Main.lean} | 0 ...e1e617ced36db.Recursion.Main.process.json} | 2 +- ...adb7e0e1e617ced36db.Recursion.Syntax.lean} | 0 ...e617ced36db.Recursion.Syntax.process.json} | 2 +- ...91.LexLeanRuntime.Collections.process.json | 1 - ...10d91.LexLeanRuntime.Portable.process.json | 1 - ...be.Pd478905735ed8adb7e0e1e617ced36db.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/recursion/lexlean.lock | 2 +- .../expected/build/manifest.json | 2 +- .../build/maps/RecursiveData/Main.map.json | 2 +- .../build/maps/RecursiveData/Types.map.json | 2 +- ...3548df5adbfe48600.RecursiveData.Main.lean} | 0 ...dbfe48600.RecursiveData.Main.process.json} | 2 +- ...548df5adbfe48600.RecursiveData.Types.lean} | 0 ...bfe48600.RecursiveData.Types.process.json} | 2 +- ...be.P6a8a70f31374da43548df5adbfe48600.lean} | 0 .../expected/verify/probe/process.json | 2 +- examples/recursive-data/lexlean.lock | 2 +- stdlib/expected/build/manifest.json | 2 +- .../build/maps/LexLeanStd/Text.map.json | 2 +- stdlib/lexlean.lock | 2 +- .../application-arity/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../binder-capture/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../project/lexlean.lock | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../project/lexlean.lock | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../certificate-rejected/project/lexlean.lock | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../escaping-closure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../extraction-rejected/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../graph-duplicate-edge/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-capture-extra/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-type-mismatch/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lowering-size-limit/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-false-evidence/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-missing-entry/project/lexlean.lock | 2 +- .../model-opaque-member/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-vacuous-claim/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../mutual-label-shared/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../preservation-drift/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../reasoning-no-rules/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../recursive-structure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../packages/rust-core/bits/package.json | 2 +- .../packages/rust-core/bits/provenance.json | 2 +- .../packages/rust-core/builders/package.json | 2 +- .../rust-core/builders/provenance.json | 2 +- .../rust-core/conversions/package.json | 2 +- .../rust-core/conversions/provenance.json | 2 +- .../rust-core/fixed_middle/package.json | 2 +- .../rust-core/fixed_middle/provenance.json | 2 +- .../rust-core/fixed_small/package.json | 2 +- .../rust-core/fixed_small/provenance.json | 2 +- .../rust-core/fixed_wide/package.json | 2 +- .../rust-core/fixed_wide/provenance.json | 2 +- .../packages/rust-core/higher/package.json | 2 +- .../packages/rust-core/higher/provenance.json | 2 +- .../packages/rust-core/int_ops/package.json | 2 +- .../rust-core/int_ops/provenance.json | 2 +- .../packages/rust-core/nat_ops/package.json | 2 +- .../rust-core/nat_ops/provenance.json | 2 +- .../packages/rust-core/options/package.json | 2 +- .../rust-core/options/provenance.json | 2 +- .../packages/rust-core/pairs/package.json | 2 +- .../packages/rust-core/pairs/provenance.json | 2 +- .../packages/rust-core/parity/package.json | 2 +- .../packages/rust-core/parity/provenance.json | 2 +- .../packages/rust-core/records/package.json | 2 +- .../rust-core/records/provenance.json | 2 +- .../packages/rust-core/shapes/package.json | 2 +- .../packages/rust-core/shapes/provenance.json | 2 +- .../rust-core/well_founded/package.json | 2 +- .../rust-core/well_founded/provenance.json | 2 +- .../packages/rust-std/bits/package.json | 2 +- .../packages/rust-std/bits/provenance.json | 2 +- .../packages/rust-std/builders/package.json | 2 +- .../rust-std/builders/provenance.json | 2 +- .../rust-std/conversions/package.json | 2 +- .../rust-std/conversions/provenance.json | 2 +- .../packages/rust-std/decimals/package.json | 2 +- .../rust-std/decimals/provenance.json | 2 +- .../rust-std/fixed_middle/package.json | 2 +- .../rust-std/fixed_middle/provenance.json | 2 +- .../rust-std/fixed_small/package.json | 2 +- .../rust-std/fixed_small/provenance.json | 2 +- .../packages/rust-std/fixed_wide/package.json | 2 +- .../rust-std/fixed_wide/provenance.json | 2 +- .../packages/rust-std/folds/package.json | 2 +- .../packages/rust-std/folds/provenance.json | 2 +- .../packages/rust-std/formats/package.json | 2 +- .../packages/rust-std/formats/provenance.json | 2 +- .../packages/rust-std/graphs/package.json | 2 +- .../packages/rust-std/graphs/provenance.json | 2 +- .../packages/rust-std/grove_root/package.json | 2 +- .../rust-std/grove_root/provenance.json | 2 +- .../packages/rust-std/higher/package.json | 2 +- .../packages/rust-std/higher/provenance.json | 2 +- .../packages/rust-std/int_ops/package.json | 2 +- .../packages/rust-std/int_ops/provenance.json | 2 +- .../packages/rust-std/iterations/package.json | 2 +- .../rust-std/iterations/provenance.json | 2 +- .../packages/rust-std/key_types/package.json | 2 +- .../rust-std/key_types/provenance.json | 2 +- .../packages/rust-std/literals/package.json | 2 +- .../rust-std/literals/provenance.json | 2 +- .../rust-std/map_folding/package.json | 2 +- .../rust-std/map_folding/provenance.json | 2 +- .../packages/rust-std/map_ops/package.json | 2 +- .../packages/rust-std/map_ops/provenance.json | 2 +- .../packages/rust-std/mapped/package.json | 2 +- .../packages/rust-std/mapped/provenance.json | 2 +- .../packages/rust-std/nat_ops/package.json | 2 +- .../packages/rust-std/nat_ops/provenance.json | 2 +- .../packages/rust-std/options/package.json | 2 +- .../packages/rust-std/options/provenance.json | 2 +- .../packages/rust-std/pairs/package.json | 2 +- .../packages/rust-std/pairs/provenance.json | 2 +- .../packages/rust-std/parity/package.json | 2 +- .../packages/rust-std/parity/provenance.json | 2 +- .../packages/rust-std/records/package.json | 2 +- .../packages/rust-std/records/provenance.json | 2 +- .../packages/rust-std/rewrite/package.json | 2 +- .../packages/rust-std/rewrite/provenance.json | 2 +- .../packages/rust-std/rose_total/package.json | 2 +- .../rust-std/rose_total/provenance.json | 2 +- .../packages/rust-std/sequences/package.json | 2 +- .../rust-std/sequences/provenance.json | 2 +- .../packages/rust-std/set_ops/package.json | 2 +- .../packages/rust-std/set_ops/provenance.json | 2 +- .../packages/rust-std/shapes/package.json | 2 +- .../packages/rust-std/shapes/provenance.json | 2 +- .../rust-std/string_graph/package.json | 2 +- .../rust-std/string_graph/provenance.json | 2 +- .../rust-std/syntax_total/package.json | 2 +- .../rust-std/syntax_total/provenance.json | 2 +- .../packages/rust-std/text/package.json | 2 +- .../packages/rust-std/text/provenance.json | 2 +- .../packages/rust-std/tree_total/package.json | 2 +- .../rust-std/tree_total/provenance.json | 2 +- .../rust-std/well_founded/package.json | 2 +- .../rust-std/well_founded/provenance.json | 2 +- .../rust-core/checked_sum/package.json | 2 +- .../rust-core/checked_sum/provenance.json | 2 +- .../packages/rust-core/halvings/package.json | 2 +- .../rust-core/halvings/provenance.json | 2 +- .../packages/rust-core/quadruple/package.json | 2 +- .../rust-core/quadruple/provenance.json | 2 +- .../rust-core/shape_area/package.json | 2 +- .../rust-core/shape_area/provenance.json | 2 +- .../rust-std/checked_sum/package.json | 2 +- .../rust-std/checked_sum/provenance.json | 2 +- .../packages/rust-std/halvings/package.json | 2 +- .../rust-std/halvings/provenance.json | 2 +- .../packages/rust-std/head_or/package.json | 2 +- .../packages/rust-std/head_or/provenance.json | 2 +- .../packages/rust-std/quadruple/package.json | 2 +- .../rust-std/quadruple/provenance.json | 2 +- .../packages/rust-std/shape_area/package.json | 2 +- .../rust-std/shape_area/provenance.json | 2 +- .../packages/rust-std/sum_all/package.json | 2 +- .../packages/rust-std/sum_all/provenance.json | 2 +- .../packages/rust-std/ends_with/package.json | 2 +- .../rust-std/ends_with/provenance.json | 2 +- .../packages/rust-std/find/package.json | 2 +- .../packages/rust-std/find/provenance.json | 2 +- .../packages/rust-std/join_with/package.json | 2 +- .../rust-std/join_with/provenance.json | 2 +- .../packages/rust-std/lines/package.json | 2 +- .../packages/rust-std/lines/provenance.json | 2 +- .../packages/rust-std/split_on/package.json | 2 +- .../rust-std/split_on/provenance.json | 2 +- .../rust-std/starts_with/package.json | 2 +- .../rust-std/starts_with/provenance.json | 2 +- .../packages/rust-std/trim/package.json | 2 +- .../packages/rust-std/trim/provenance.json | 2 +- .../commands/expected/build/manifest.json | 2 +- .../build/maps/ToolingCommands/Main.map.json | 2 +- .../tooling/core/expected/build/manifest.json | 2 +- .../build/maps/ToolingCore/Main.map.json | 2 +- .../traversal/expected/build/manifest.json | 2 +- .../build/maps/ToolingTraversal/Main.map.json | 2 +- 1957 files changed, 3044 insertions(+), 3044 deletions(-) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.lean => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.lean} (100%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.process.json => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.process.json} (94%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.lean => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.lean} (100%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.process.json => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.process.json} (60%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.lean => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.lean} (100%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.process.json => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.process.json} (71%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.lean => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.lean} (100%) rename examples/{fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.process.json => collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.process.json} (97%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.lean => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.lean} (100%) rename examples/collections/expected/verify/audit/{LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.process.json => LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.process.json} (98%) rename examples/collections/expected/verify/probe/{LexLeanProbe.P9962d043362f4a167c67517d483f0f24.lean => LexLeanProbe.P0f6d359d50d0d086f47af2c0608b2e13.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.process.json => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.process.json} (85%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.process.json => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.process.json} (85%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.process.json => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.process.json} (74%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.lean} (100%) rename examples/{models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.process.json => fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.process.json} (97%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.process.json => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.process.json} (95%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.lean => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.lean} (100%) rename examples/fold-laws/expected/verify/audit/{LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.process.json => LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.process.json} (98%) rename examples/fold-laws/expected/verify/probe/{LexLeanProbe.P3cc5e8a42a7c9d201fd51d5ce22fd4f8.lean => LexLeanProbe.P1d59f84598c9f4c2cea21d972760d780.lean} (100%) rename examples/higher-order/expected/verify/audit/{LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.lean => LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.lean} (100%) rename examples/higher-order/expected/verify/audit/{LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.process.json => LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.process.json} (80%) rename examples/higher-order/expected/verify/audit/{LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.lean => LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.lean} (100%) rename examples/higher-order/expected/verify/audit/{LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.process.json => LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.process.json} (78%) rename examples/higher-order/expected/verify/probe/{LexLeanProbe.Pe5a01d2449b3b246c026e507417cc495.lean => LexLeanProbe.Pb5934bc97e423cda9eec0f05d9678db7.lean} (100%) rename examples/language-1.2/expected/verify/audit/{LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.lean => LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.lean} (100%) rename examples/language-1.2/expected/verify/audit/{LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.process.json => LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.process.json} (61%) rename examples/language-1.2/expected/verify/probe/{LexLeanProbe.P91252ea0ee170a673bd0462010771fa8.lean => LexLeanProbe.P8f90c02b42edd596631d3fdfeeada166.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.lean} (100%) rename examples/{production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.process.json => models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.process.json} (97%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.process.json} (95%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.process.json} (90%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.process.json} (98%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.process.json} (95%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.process.json} (67%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.process.json} (95%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.process.json} (94%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.process.json} (91%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.process.json} (81%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.process.json} (92%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.process.json} (86%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.lean => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.lean} (100%) rename examples/models/expected/verify/audit/{LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.process.json => LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.process.json} (87%) rename examples/models/expected/verify/extract/{LexLeanExtract.X49cf062e918bdc2f8a44a66473c4435e.lean => LexLeanExtract.X91b57d30cfd6f60128d6c72e374148ef.lean} (100%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R0.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R0/Compose/RustStd.lex.tex (93%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R0/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R1.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R1/Compose/RustStd.lex.tex (93%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R1/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R2.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R2/Compose/RustStd.lex.tex (93%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R2/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R3.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R3/Compose/RustStd.lex.tex (94%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R3/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R4.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R4/Compose/RustStd.lex.tex (93%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R4/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R5.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R5/Compose/RustStd.lex.tex (94%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R5/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R6.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R6/Compose/RustStd.lex.tex (94%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R6/RustStd.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R7.lean (98%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R7/Compose/RustStd.lex.tex (93%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R7/RustStd.lean (98%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R8.lean (99%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R8/Compose/RustStd.lex.tex (94%) rename examples/models/expected/verify/preserve/LexLeanPreserve/{C49cf062e918bdc2f8a44a66473c4435e => C91b57d30cfd6f60128d6c72e374148ef}/R8/RustStd.lean (99%) rename examples/models/expected/verify/probe/{LexLeanProbe.P49cf062e918bdc2f8a44a66473c4435e.lean => LexLeanProbe.P91b57d30cfd6f60128d6c72e374148ef.lean} (100%) delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json delete mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json rename examples/models/expected/verify/process/leanchecker/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json} (58%) create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json rename examples/models/expected/verify/process/leanchecker/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json} (58%) create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json rename examples/models/expected/verify/process/leanchecker/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json} (58%) create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json rename examples/models/expected/verify/process/leanchecker/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json} (58%) create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json create mode 100644 examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json delete mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json} (57%) rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json} (55%) create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json} (57%) rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json} (55%) create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json} (57%) rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json} (55%) create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json} (57%) rename examples/models/expected/verify/process/preserve/{LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json} (55%) create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json create mode 100644 examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.process.json} (62%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.process.json} (75%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.process.json} (76%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.process.json} (76%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.process.json} (64%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.process.json} (88%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.process.json} (61%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.process.json} (77%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.lean} (100%) rename examples/{collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.process.json => production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.process.json} (97%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.lean} (100%) rename examples/{production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.process.json => production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.process.json} (96%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.lean => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.lean} (100%) rename examples/production-coverage/expected/verify/audit/{LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.process.json => LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.process.json} (98%) rename examples/production-coverage/expected/verify/extract/{LexLeanExtract.Xf3572b43e36d5c62b7601d32507ebc3a.lean => LexLeanExtract.Xe05bf7cb47aac48ea11c4a7ac75c7962.lean} (100%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R0.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R0/Compose/RustStd.lex.tex (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R0/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R1.lean (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R1/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R1/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R10.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R10/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R10/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R10/RustCore.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R10/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R11.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R11/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R11/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R11/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R11/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R12.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R12/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R12/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R12/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R12/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R13.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R13/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R13/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R14.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R14/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R14/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R14/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R14/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R15.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R15/Compose/RustCore.lex.tex (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R15/Compose/RustStd.lex.tex (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R15/RustCore.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R15/RustStd.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R16.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R16/Compose/RustCore.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R16/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R16/RustCore.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R16/RustStd.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R17.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R17/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R17/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R17/RustCore.lean (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R17/RustStd.lean (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R18.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R18/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R18/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R18/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R18/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R19.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R19/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R19/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R2.lean (87%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R2/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R2/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R20.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R20/Compose/RustCore.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R20/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R20/RustCore.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R20/RustStd.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R21.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R21/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R21/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R21/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R21/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R22.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R22/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R22/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R22/RustCore.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R22/RustStd.lean (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R23.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R23/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R23/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R23/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R23/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R24.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R24/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R24/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R24/RustCore.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R24/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R25.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R25/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R25/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R25/RustCore.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R25/RustStd.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R26.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R26/Compose/RustStd.lex.tex (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R26/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R27.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R27/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R27/RustStd.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R28.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R28/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R28/RustStd.lean (95%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R29.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R29/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R29/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R3.lean (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R3/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R3/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R30.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R30/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R30/RustStd.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R31.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R31/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R31/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R32.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R32/Compose/RustCore.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R32/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R32/RustCore.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R32/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R33.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R33/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R33/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R4.lean (87%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R4/Compose/RustStd.lex.tex (93%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R4/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R5.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R5/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R5/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R6.lean (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R6/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R6/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R7.lean (92%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R7/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R7/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R8.lean (96%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R8/Compose/RustStd.lex.tex (97%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R8/RustStd.lean (99%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R9.lean (98%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R9/Compose/RustStd.lex.tex (94%) rename examples/production-coverage/expected/verify/preserve/LexLeanPreserve/{Cf3572b43e36d5c62b7601d32507ebc3a => Ce05bf7cb47aac48ea11c4a7ac75c7962}/R9/RustStd.lean (97%) rename examples/production-coverage/expected/verify/probe/{LexLeanProbe.Pf3572b43e36d5c62b7601d32507ebc3a.lean => LexLeanProbe.Pe05bf7cb47aac48ea11c4a7ac75c7962.lean} (100%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json} (57%) rename examples/{production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json => production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json} (57%) rename examples/{production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json => production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json} (59%) rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json} (57%) rename examples/{production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json => production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json} (59%) rename examples/{production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json => production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json} (59%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json rename examples/production-coverage/expected/verify/process/leanchecker/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json} (56%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json} (55%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json} (56%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json} (55%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json} (56%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json} (55%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json} (57%) rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json} (55%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json} (57%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json} (56%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json rename examples/production-coverage/expected/verify/process/preserve/{LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json => LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json} (68%) create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json create mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json delete mode 100644 examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json delete mode 100644 examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.process.json delete mode 100644 examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.process.json rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.lean => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.lean} (100%) create mode 100644 examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.process.json rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.lean => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.lean} (100%) rename examples/{recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.process.json => production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.process.json} (96%) rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.lean => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.lean} (100%) create mode 100644 examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.process.json rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.lean => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.lean} (100%) rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.process.json => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.process.json} (74%) rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.lean => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.lean} (100%) rename examples/production/expected/verify/audit/{LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.process.json => LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.process.json} (72%) rename examples/production/expected/verify/extract/{LexLeanExtract.Xecf58505f4e2844618eff0bdc9a2ce9d.lean => LexLeanExtract.Xf5a58e441acc8b93ded11826c51cc7c8.lean} (100%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R0.lean (95%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R0/Compose/RustCore.lex.tex (94%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R0/Compose/RustStd.lex.tex (94%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R0/RustCore.lean (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R0/RustStd.lean (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R1.lean (98%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R1/Compose/RustCore.lex.tex (94%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R1/Compose/RustStd.lex.tex (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R1/RustCore.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R1/RustStd.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R2.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R2/Compose/RustCore.lex.tex (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R2/Compose/RustStd.lex.tex (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R2/RustCore.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R2/RustStd.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R3.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R3/Compose/RustCore.lex.tex (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R3/Compose/RustStd.lex.tex (93%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R3/RustCore.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R3/RustStd.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R4.lean (96%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R4/Compose/RustStd.lex.tex (94%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R4/RustStd.lean (96%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R5.lean (97%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R5/Compose/RustStd.lex.tex (94%) rename examples/production/expected/verify/preserve/LexLeanPreserve/{Cecf58505f4e2844618eff0bdc9a2ce9d => Cf5a58e441acc8b93ded11826c51cc7c8}/R5/RustStd.lean (96%) rename examples/production/expected/verify/probe/{LexLeanProbe.Pecf58505f4e2844618eff0bdc9a2ce9d.lean => LexLeanProbe.Pf5a58e441acc8b93ded11826c51cc7c8.lean} (100%) delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json delete mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json rename examples/{production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json => production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json rename examples/{production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json => production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json rename examples/{production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json => production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json rename examples/{production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json => production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json create mode 100644 examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json delete mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json rename examples/production/expected/verify/process/preserve/{LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json rename examples/production/expected/verify/process/preserve/{LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json rename examples/production/expected/verify/process/preserve/{LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json rename examples/production/expected/verify/process/preserve/{LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json} (57%) create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json create mode 100644 examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.lean} (100%) create mode 100644 examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.process.json rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.lean} (100%) rename examples/{production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.process.json => reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.process.json} (95%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.process.json} (90%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.lean} (100%) create mode 100644 examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.process.json rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.process.json} (94%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.process.json} (96%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.process.json} (98%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.process.json} (97%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.process.json} (98%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.lean => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.lean} (100%) rename examples/reasoning/expected/verify/audit/{LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.process.json => LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.process.json} (95%) delete mode 100644 examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.process.json delete mode 100644 examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.process.json delete mode 100644 examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.process.json rename examples/reasoning/expected/verify/extract/{LexLeanExtract.X7b45b58d681c076cfd69727310b65f3f.lean => LexLeanExtract.X02b315b69b8881ec6f91f78f9b12c608.lean} (100%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R0.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R0/Compose/RustCore.lex.tex (96%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R0/RustCore.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R1.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R1/Compose/RustCore.lex.tex (96%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R1/RustCore.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R2.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R2/Compose/RustStd.lex.tex (96%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R2/RustStd.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R3.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R3/Compose/RustStd.lex.tex (95%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R3/RustStd.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R4.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R4/Compose/RustStd.lex.tex (95%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R4/RustStd.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R5.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R5/Compose/RustCore.lex.tex (96%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R5/RustCore.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R6.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R6/Compose/RustStd.lex.tex (95%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R6/RustStd.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R7.lean (99%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R7/Compose/RustStd.lex.tex (93%) rename examples/reasoning/expected/verify/preserve/LexLeanPreserve/{C7b45b58d681c076cfd69727310b65f3f => C02b315b69b8881ec6f91f78f9b12c608}/R7/RustStd.lean (99%) rename examples/reasoning/expected/verify/probe/{LexLeanProbe.P7b45b58d681c076cfd69727310b65f3f.lean => LexLeanProbe.P02b315b69b8881ec6f91f78f9b12c608.lean} (100%) create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json create mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json delete mode 100644 examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.lean => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.lean} (100%) create mode 100644 examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.process.json rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.lean => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.lean} (100%) create mode 100644 examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.process.json rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.lean => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.lean} (100%) create mode 100644 examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.process.json rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.lean => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.lean} (100%) rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.process.json => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.process.json} (90%) rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.lean => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.lean} (100%) rename examples/recursion/expected/verify/audit/{LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.process.json => LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.process.json} (61%) delete mode 100644 examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.process.json delete mode 100644 examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.process.json rename examples/recursion/expected/verify/probe/{LexLeanProbe.Pfca4cff7cd9d7d680879d32a7e810d91.lean => LexLeanProbe.Pd478905735ed8adb7e0e1e617ced36db.lean} (100%) rename examples/recursive-data/expected/verify/audit/{LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.lean => LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.lean} (100%) rename examples/recursive-data/expected/verify/audit/{LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.process.json => LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.process.json} (82%) rename examples/recursive-data/expected/verify/audit/{LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.lean => LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.lean} (100%) rename examples/recursive-data/expected/verify/audit/{LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.process.json => LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.process.json} (72%) rename examples/recursive-data/expected/verify/probe/{LexLeanProbe.P2c35ce90452a8eb92de5f1e3f4d23947.lean => LexLeanProbe.P6a8a70f31374da43548df5adbfe48600.lean} (100%) diff --git a/compiler/expected/build/manifest.json b/compiler/expected/build/manifest.json index c9799fdcc..e4a22935c 100644 --- a/compiler/expected/build/manifest.json +++ b/compiler/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"d2394dbebd54cfcf1112d8ad33dc297bd885b2402527bdc929307f6e067f18e8","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"759ffb53325d73f0c6eae858adee03cdf7c7f22e952526dfe5dcea6a2e837f3f"},{"byte_length":643,"kind":"project-config","path":"lexlean.toml","sha256":"ef58478b65de0ad784269ab3513059f5afbb7f461bda9476efce78344301755e"},{"byte_length":4612,"kind":"source","path":"src/BudgetOracle.lex.tex","sha256":"c6545653dc603ec6710e038653686bd57e4b0e71fe362957cb0f0a5722898802"},{"byte_length":47895,"kind":"source","path":"src/Certification.lex.tex","sha256":"7e011c2fefdfd08c3f9d41a5cf5c891d72495aae7d4bc1e0b5d31a9d364c07fb"},{"byte_length":100847,"kind":"source","path":"src/Gnaf.lex.tex","sha256":"21b9c9174ae33fe77204e196a29a51463f2c9a400f7b305d33591c54f31d798d"},{"byte_length":105623,"kind":"source","path":"src/GnafCertificates.lex.tex","sha256":"498dafa5093f56f0a05bbddb58875aebc0769325386f2ca611f3a101d9368f64"},{"byte_length":680712,"kind":"source","path":"src/GnafFixtures.lex.tex","sha256":"e7f06e087d0ec40b8dd61f2fe1c51258ec55d93f5e5e16938c27598661e8d913"},{"byte_length":5030,"kind":"source","path":"src/GradeOracle.lex.tex","sha256":"1e19782f0fd76c6d49b5f7f5f29569f8f52b5d91397f0ec9921286cdd03b0fd0"},{"byte_length":811,"kind":"source","path":"src/Main.lex.tex","sha256":"a26d3c220ec1352dd96565ac2308c1684a945a98e1210b3dfaab30cd76dc1875"},{"byte_length":8685,"kind":"source","path":"src/PlannerOracle.lex.tex","sha256":"8579b13fcc26a5bdd3323388f400d1b0b805359f96fe4beea29b26bbaa79f50b"},{"byte_length":699968,"kind":"source","path":"src/ReasoningFixtures.lex.tex","sha256":"21de0c44ebce81bb7bb1b05a6e29815cc2e6c19a58a4c85459110bf3fd1dee9c"},{"byte_length":27419,"kind":"source","path":"src/ReasoningOracle.lex.tex","sha256":"7d5e680324c4fbffa4b8906aefe2e502d20994ff8cdaf223eb385e814bec77bb"},{"byte_length":103523,"kind":"source","path":"src/RustSemantics.lex.tex","sha256":"183644ea3d81403440add2ca225c82d462dde21a7c5a7928d2c313a12e9242b3"},{"byte_length":7619,"kind":"source","path":"src/RustSyntax.lex.tex","sha256":"9cbc4da6fc9441a03954f0979cbe4812aae0426811932e6ff1d6661043d3611f"},{"byte_length":3620,"kind":"source","path":"src/ScreeningOracle.lex.tex","sha256":"23fe7cb8804846c5418204184105f7381f5f36ddd2cdd1beec466416b5d12cb9"},{"byte_length":654074,"kind":"source","path":"src/TargetFixtures.lex.tex","sha256":"d746739ea3e78234f7a68280dc068d39b84f4064298a37383a8dc645bc188c27"},{"byte_length":2490,"kind":"source","path":"src/TargetOracle.lex.tex","sha256":"e34fca12090e04d8a853d4edfc9ae8db46d09ec586f2820f25d69c8ab3a7fb2d"},{"byte_length":426639,"kind":"source","path":"src/TargetSemantics.lex.tex","sha256":"92551ec717ba14a68c53203b5ea1f68359902201116de69c2816668038eb4a60"},{"byte_length":5518,"kind":"source","path":"src/TargetSyntax.lex.tex","sha256":"943d39daf9ece2d492cf8b15ba2df218f84031dbf0757b8ee765d240df55276e"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanTarget.BudgetOracle","module":"BudgetOracle","source_path":"src/BudgetOracle.lex.tex"},{"lean_module":"LexLeanTarget.Certification","module":"Certification","source_path":"src/Certification.lex.tex"},{"lean_module":"LexLeanTarget.Gnaf","module":"Gnaf","source_path":"src/Gnaf.lex.tex"},{"lean_module":"LexLeanTarget.GnafCertificates","module":"GnafCertificates","source_path":"src/GnafCertificates.lex.tex"},{"lean_module":"LexLeanTarget.GnafFixtures","module":"GnafFixtures","source_path":"src/GnafFixtures.lex.tex"},{"lean_module":"LexLeanTarget.GradeOracle","module":"GradeOracle","source_path":"src/GradeOracle.lex.tex"},{"lean_module":"LexLeanTarget.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"LexLeanTarget.PlannerOracle","module":"PlannerOracle","source_path":"src/PlannerOracle.lex.tex"},{"lean_module":"LexLeanTarget.ReasoningFixtures","module":"ReasoningFixtures","source_path":"src/ReasoningFixtures.lex.tex"},{"lean_module":"LexLeanTarget.ReasoningOracle","module":"ReasoningOracle","source_path":"src/ReasoningOracle.lex.tex"},{"lean_module":"LexLeanTarget.RustSemantics","module":"RustSemantics","source_path":"src/RustSemantics.lex.tex"},{"lean_module":"LexLeanTarget.RustSyntax","module":"RustSyntax","source_path":"src/RustSyntax.lex.tex"},{"lean_module":"LexLeanTarget.ScreeningOracle","module":"ScreeningOracle","source_path":"src/ScreeningOracle.lex.tex"},{"lean_module":"LexLeanTarget.TargetFixtures","module":"TargetFixtures","source_path":"src/TargetFixtures.lex.tex"},{"lean_module":"LexLeanTarget.TargetOracle","module":"TargetOracle","source_path":"src/TargetOracle.lex.tex"},{"lean_module":"LexLeanTarget.TargetSemantics","module":"TargetSemantics","source_path":"src/TargetSemantics.lex.tex"},{"lean_module":"LexLeanTarget.TargetSyntax","module":"TargetSyntax","source_path":"src/TargetSyntax.lex.tex"}],"outputs":[{"byte_length":11181,"kind":"coverage","path":"coverage/LexLeanTarget/BudgetOracle.coverage.json","sha256":"4c38c35c5f0cf117c7cfc0139ea1d78d74ba3687f38e2b90783bb5b92b6cd064"},{"byte_length":27889,"kind":"coverage","path":"coverage/LexLeanTarget/Certification.coverage.json","sha256":"d1fd9f61561ef5bf24e63f9909565eb91ae3ab75c0dcb99fe3d58c683536af92"},{"byte_length":49254,"kind":"coverage","path":"coverage/LexLeanTarget/Gnaf.coverage.json","sha256":"0d50115903a6801a603450a86c3916b027d999d99a86635329fb894f776f92ad"},{"byte_length":57711,"kind":"coverage","path":"coverage/LexLeanTarget/GnafCertificates.coverage.json","sha256":"11987f846c4397e765f1678df11775374c59d34dc8c5943d8929d71297760633"},{"byte_length":66645,"kind":"coverage","path":"coverage/LexLeanTarget/GnafFixtures.coverage.json","sha256":"bd9dab4cd246a183b9db20001c3b172ca748b474553f1bc30b14f6d0dda92734"},{"byte_length":10429,"kind":"coverage","path":"coverage/LexLeanTarget/GradeOracle.coverage.json","sha256":"394cf22f3967a4e544cb42caf7005a4c557bd63b56c465d58ad251179d555fc2"},{"byte_length":16662,"kind":"coverage","path":"coverage/LexLeanTarget/Main.coverage.json","sha256":"ac5e6c5061f44d9d2708be6a63546834eba79fecbb2230b0e3458c5af3c43989"},{"byte_length":15869,"kind":"coverage","path":"coverage/LexLeanTarget/PlannerOracle.coverage.json","sha256":"68fa5c011e011d56e6d0273084d5af91f1783d733ee710eab3a25b1a7cb4b391"},{"byte_length":34095,"kind":"coverage","path":"coverage/LexLeanTarget/ReasoningFixtures.coverage.json","sha256":"12c71e696f141058f795f256a1b658b73cbe5523fc418807ee163e4a8100b901"},{"byte_length":21934,"kind":"coverage","path":"coverage/LexLeanTarget/ReasoningOracle.coverage.json","sha256":"c4e1e0cc85511589d275588b731d2c0dea9ed3f9ad7f3a6dfb3804175767ed73"},{"byte_length":19509,"kind":"coverage","path":"coverage/LexLeanTarget/RustSemantics.coverage.json","sha256":"a1db132f98ddbcf22dc61de28715de5a4e328728ec2b47c0c626ba1d3dafde74"},{"byte_length":12534,"kind":"coverage","path":"coverage/LexLeanTarget/RustSyntax.coverage.json","sha256":"b3469906edbf88096e355b158222af2ff743d2b6c623562c452d152a9cf571c9"},{"byte_length":11293,"kind":"coverage","path":"coverage/LexLeanTarget/ScreeningOracle.coverage.json","sha256":"05a35bfd9204fc4711116a6323cfb3f9ce195f93a03523af68705039d8bbb068"},{"byte_length":101228,"kind":"coverage","path":"coverage/LexLeanTarget/TargetFixtures.coverage.json","sha256":"6624fc93ffffd63b7abc490cef8be822fa432ae5231488dbb57000faedecb56d"},{"byte_length":9389,"kind":"coverage","path":"coverage/LexLeanTarget/TargetOracle.coverage.json","sha256":"027cf182140446894d350ce94a425b754b854d31bfdd65c147fb4a8aa5f3ceef"},{"byte_length":17711,"kind":"coverage","path":"coverage/LexLeanTarget/TargetSemantics.coverage.json","sha256":"8c2275847f042368e2bed11862523e1c96d7cc4a56a66c954ab43f47ff9735a0"},{"byte_length":9810,"kind":"coverage","path":"coverage/LexLeanTarget/TargetSyntax.coverage.json","sha256":"6a2a365549546bf5b1ea4f2df51775ba3054c8be4e121c8594cf0868c5433524"},{"byte_length":63974,"kind":"lean","path":"modules/LexLeanTarget/BudgetOracle.lean","sha256":"33061e2080b80d31a3042e667c3f7ab7090051efcf5e67d5f0b4c384b1699cff"},{"byte_length":43091,"kind":"lean","path":"modules/LexLeanTarget/Certification.lean","sha256":"0484010f2efcdb78dd9bb28c7294d41f1587af73993e1f15466b1f372019ab6a"},{"byte_length":84874,"kind":"lean","path":"modules/LexLeanTarget/Gnaf.lean","sha256":"962a93bd8f993c56c9bdfafd527fe52c49a3868fc2180460ee11292f21898c9e"},{"byte_length":105947,"kind":"lean","path":"modules/LexLeanTarget/GnafCertificates.lean","sha256":"3fac84aa9e8110b50cc2cf24ff9d4f49d1a7b49a816137f43497b6c3c5e78f09"},{"byte_length":850353,"kind":"lean","path":"modules/LexLeanTarget/GnafFixtures.lean","sha256":"ca5db55769dfd1579762d2b5b6a004213895dbff0bb498dc10743d863d2a2315"},{"byte_length":44805,"kind":"lean","path":"modules/LexLeanTarget/GradeOracle.lean","sha256":"ea724bef2e4aafca56bc03452d8da8935c360841481997fc9b04bec7d205719f"},{"byte_length":1128,"kind":"lean","path":"modules/LexLeanTarget/Main.lean","sha256":"cb359700a417929e8ff9dbb35fd9ff41f0eda211b7c36009d7b7e92d7baeff13"},{"byte_length":171727,"kind":"lean","path":"modules/LexLeanTarget/PlannerOracle.lean","sha256":"a1590a1076cfca401cb1bfb72ca5b07363752f56ab4eae07f147d16b6d8e145c"},{"byte_length":896707,"kind":"lean","path":"modules/LexLeanTarget/ReasoningFixtures.lean","sha256":"cccf75a8f6c6d61da06a30177ab5001ec36132d16ee916d46c6d102d781a8d20"},{"byte_length":151030,"kind":"lean","path":"modules/LexLeanTarget/ReasoningOracle.lean","sha256":"ac78fb8128e5b859ed9b00bcfebdd57db1db0e3a1b9b95c54e92f6ecb77e17c1"},{"byte_length":86991,"kind":"lean","path":"modules/LexLeanTarget/RustSemantics.lean","sha256":"e19e285327ea0eead677ef40d4fb3a9d0b297570e432c4ee357af7a7abc9b6b9"},{"byte_length":4479,"kind":"lean","path":"modules/LexLeanTarget/RustSyntax.lean","sha256":"868130ffaf54b20c9941a5aa4f7020c4a2ee403f4ca5dc4624fd3199d50e4b54"},{"byte_length":45937,"kind":"lean","path":"modules/LexLeanTarget/ScreeningOracle.lean","sha256":"6e65882bc5d2591f8b4da728f510478a6aa621d92e718ab918cbec4c5327f368"},{"byte_length":802797,"kind":"lean","path":"modules/LexLeanTarget/TargetFixtures.lean","sha256":"2aa09bdc3b28620ffbf96e843d59c667ac7836c704951e95f7d14fcc93d56a9c"},{"byte_length":2355,"kind":"lean","path":"modules/LexLeanTarget/TargetOracle.lean","sha256":"473b7729d1679099d5b81865f794eff6a68308c9cfa3b0ca61d8d1c7eadfffc3"},{"byte_length":343014,"kind":"lean","path":"modules/LexLeanTarget/TargetSemantics.lean","sha256":"f8f6c6085c0dd1bbc8b6cd8fc49d4c3800e65c9c0033874c735341edef1291b9"},{"byte_length":2780,"kind":"lean","path":"modules/LexLeanTarget/TargetSyntax.lean","sha256":"c0e0bb061cfcdc7e7f4434e13fc8b7298dcb701db9ea8189e012d8068e04ee0c"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/BudgetOracle.closure.json","sha256":"77b793d6eeb5f55f9ee2676c6e61ecfcf8a47b1c7686bf8b5b82ed885098b3e5"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/Certification.closure.json","sha256":"14e70294074a52b88964920e91dbd1aec0c4ffe1d92a5c1d9e088a3cd3ae4630"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Gnaf.closure.json","sha256":"bf67edea690a60515a1852bd8ce58435814a28f3c729c184ed9e1416095dec25"},{"byte_length":10614,"kind":"lexicon-closure","path":"lexicons/GnafCertificates.closure.json","sha256":"091d8cfb8676ac6b1863e0ee193aca1dff96149c6174590d429cb663d3a26b2c"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/GnafFixtures.closure.json","sha256":"40c76800549e30b23ec113ded9ec8507304bc1b731f556d9ff2ffff6926aa97d"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/GradeOracle.closure.json","sha256":"b00cae435e73a9572c6db7dfd4591933c5a96e318ff62494abbb5083ecfd9a25"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/PlannerOracle.closure.json","sha256":"f29a6aa1f51c4b5482937e400c71fc118ef91bf1ddbc4076634f1ac32da50ca0"},{"byte_length":10615,"kind":"lexicon-closure","path":"lexicons/ReasoningFixtures.closure.json","sha256":"47757b8545a4270046b387e54f183e44288d14b5b5ae1e0b7a939731582d445e"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/ReasoningOracle.closure.json","sha256":"291571e44ca093a6966ef282b10abcfaff1a0e0ff6e909f543cbb16924dbdaec"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/RustSemantics.closure.json","sha256":"152f56877c9492f618bfc1eb44a6d8eb04d8ffb1e05c52f685a98efe173b9c6b"},{"byte_length":10608,"kind":"lexicon-closure","path":"lexicons/RustSyntax.closure.json","sha256":"d000985e33e8be7f26117319c5adb68380f9e7c44977c65e112e80472428cd79"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/ScreeningOracle.closure.json","sha256":"6653713be4bb8465a19c48088477644f2065431e1008ff3b9371401eaaa011f4"},{"byte_length":10612,"kind":"lexicon-closure","path":"lexicons/TargetFixtures.closure.json","sha256":"40cf03e3d335319ccbd3328e8eff2af5867f25d16c05d8f2303ff1ba414b57a1"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/TargetOracle.closure.json","sha256":"7834c4ed29b8d8fc6acd24325adba002e08e766d77f5b5a3e64afe6aab086b1f"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/TargetSemantics.closure.json","sha256":"5649cb299c72ad2bf7cd8ff70369be255cd0f52c7cc980807e6e1a7544f884c9"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/TargetSyntax.closure.json","sha256":"c1860f7ba449c93990d46c5f27eeeaabf17e319169e0a37fe21efc12999de2aa"},{"byte_length":6212,"kind":"map","path":"maps/LexLeanTarget/BudgetOracle.map.json","sha256":"82b30850badc7158d13074e8a680d37e9503cdd4f4892386fa9f8d62cd281768"},{"byte_length":24054,"kind":"map","path":"maps/LexLeanTarget/Certification.map.json","sha256":"fea6ac044862251351c69d011510910125c1fca77c04819c43044f94e2ddcd30"},{"byte_length":51466,"kind":"map","path":"maps/LexLeanTarget/Gnaf.map.json","sha256":"d964ec1c17bef0b0e8941a6e3d033099e118ba94c85dc027b9698fdb9e9d79d0"},{"byte_length":58783,"kind":"map","path":"maps/LexLeanTarget/GnafCertificates.map.json","sha256":"b72eb0f1fd3d6a85ab576c0454aa916f7aa5b9170589e80cde0bd2c374618f38"},{"byte_length":72111,"kind":"map","path":"maps/LexLeanTarget/GnafFixtures.map.json","sha256":"4b201f5daf0c7f38f26fffff29c84d6a864d7ee4d785ca4e9fe4187792269e53"},{"byte_length":4588,"kind":"map","path":"maps/LexLeanTarget/GradeOracle.map.json","sha256":"eeea52463a6a8af88ee9ef07a98f5cb12a2c1df2ec95c135606bd9faaaabc9e3"},{"byte_length":1352,"kind":"map","path":"maps/LexLeanTarget/Main.map.json","sha256":"c14ec3e226bb7abb1e2d4a465ef486fd20bbe0cd7afb1364bc226873234e5ece"},{"byte_length":11761,"kind":"map","path":"maps/LexLeanTarget/PlannerOracle.map.json","sha256":"0b0eac2565c8dab94d1c31977acdb05bbf1380a003a602da784204c6b5104fb1"},{"byte_length":28320,"kind":"map","path":"maps/LexLeanTarget/ReasoningFixtures.map.json","sha256":"75e160c90a806ed22116ae5288c97357d39e154bc0e3d9d602c3186de66f65ac"},{"byte_length":19059,"kind":"map","path":"maps/LexLeanTarget/ReasoningOracle.map.json","sha256":"2fb8521bed46a5235a61c5eddf73e9a18d7967773211bded71bb0576b8c781e1"},{"byte_length":13888,"kind":"map","path":"maps/LexLeanTarget/RustSemantics.map.json","sha256":"53d3e51d28067db77b654c87f8b54a440155ef7559c4b5baac27601fb2ad5465"},{"byte_length":7165,"kind":"map","path":"maps/LexLeanTarget/RustSyntax.map.json","sha256":"27604dab774f6cc0b2512d9f589133602c77fb95d21af4c5a4ed9b43aa3f8ef2"},{"byte_length":6214,"kind":"map","path":"maps/LexLeanTarget/ScreeningOracle.map.json","sha256":"1757512567fbee782345047edbb4b65915d8106e4a78346dbfbb6b3acd945c18"},{"byte_length":114575,"kind":"map","path":"maps/LexLeanTarget/TargetFixtures.map.json","sha256":"f8db30c2ab8f1f18acb0f83792efe8ca662c586d10e43cd9241b18e33bdf45dc"},{"byte_length":3299,"kind":"map","path":"maps/LexLeanTarget/TargetOracle.map.json","sha256":"7d01b60a28ed1cc92a39822295ad9ab8d5fc90bbf8be123b03d355858bbca874"},{"byte_length":13138,"kind":"map","path":"maps/LexLeanTarget/TargetSemantics.map.json","sha256":"3588e3f80c8c040e444d5609f22583f0e7e2610f4ea35fd8dc5f3aa7b4bb7f79"},{"byte_length":4584,"kind":"map","path":"maps/LexLeanTarget/TargetSyntax.map.json","sha256":"20cadabd883bfd8e58c14e81d3dd4e310948bcdfc474972afbb72cd9781ff4a4"},{"byte_length":34987,"kind":"tex","path":"modules/LexLeanTarget/BudgetOracle.tex","sha256":"e119790e14fb08097a91884bd4d4576ecf25f73b8dfb77cb8a4a6974b9bd139c"},{"byte_length":57133,"kind":"tex","path":"modules/LexLeanTarget/Certification.tex","sha256":"cbed4c0f6e9999f341c5b6d0a46956f21c506c0a3c04512328ae53aa864c6a2e"},{"byte_length":111707,"kind":"tex","path":"modules/LexLeanTarget/Gnaf.tex","sha256":"f0af7a2df200270323f7d392f404b19a93ee74aa973bf12353a519fd9783dbfa"},{"byte_length":132342,"kind":"tex","path":"modules/LexLeanTarget/GnafCertificates.tex","sha256":"b48420c115ae3fa7c592a3ae5fdf9700f65605c7b1697a139c3791e8ff5506f5"},{"byte_length":885281,"kind":"tex","path":"modules/LexLeanTarget/GnafFixtures.tex","sha256":"fe73187797328af446b1920f7895621b6c16a8d2a0874484d163ab5c5ac99722"},{"byte_length":26691,"kind":"tex","path":"modules/LexLeanTarget/GradeOracle.tex","sha256":"660efcdb6b42661eab9deb5d35f2533182161e1126453b76403d0803ae92ac04"},{"byte_length":532,"kind":"tex","path":"modules/LexLeanTarget/Main.tex","sha256":"fb9b15c8eb40ef1542e9d69a6a3a8e9c242855157699cff8453d8c44becc08ec"},{"byte_length":90367,"kind":"tex","path":"modules/LexLeanTarget/PlannerOracle.tex","sha256":"1517be188348a5e8c29ecac93545fa4ac2338e802a7a030bfec7ccc6fb5317f1"},{"byte_length":912884,"kind":"tex","path":"modules/LexLeanTarget/ReasoningFixtures.tex","sha256":"2e3f3cf3328aebec9f71f3b003e371e2f4747156548f4157e26e84d502baac63"},{"byte_length":78159,"kind":"tex","path":"modules/LexLeanTarget/ReasoningOracle.tex","sha256":"9f22e4e59d2b2515287ca787c5bbef1669441372e69d090b8dbfbc4182088896"},{"byte_length":94786,"kind":"tex","path":"modules/LexLeanTarget/RustSemantics.tex","sha256":"49c608b1f2220836d6ddbdd204a91e44cdf44eb75c3a1b12c809d3236a65496e"},{"byte_length":11151,"kind":"tex","path":"modules/LexLeanTarget/RustSyntax.tex","sha256":"6e51a9b399de99a2a43a5742ba9f6d6203055e0c84fe5a39dbe1c03a264c0511"},{"byte_length":27194,"kind":"tex","path":"modules/LexLeanTarget/ScreeningOracle.tex","sha256":"dd053d08d2811509a8659e75b228530b5bff859bb749a955297b965407bf13e4"},{"byte_length":859771,"kind":"tex","path":"modules/LexLeanTarget/TargetFixtures.tex","sha256":"d81cf82e55307a02d34c830cb4e1101cb1c5b2accff59f66cb1836cf186a3de0"},{"byte_length":3601,"kind":"tex","path":"modules/LexLeanTarget/TargetOracle.tex","sha256":"3ac498bbc1902427cc192481895d2370cfb70bc2e5242ecb90ff8e29cb2edb48"},{"byte_length":353998,"kind":"tex","path":"modules/LexLeanTarget/TargetSemantics.tex","sha256":"126ab7711ed907166c1c788f0a3b63535938e5d26ca2666243dacd81b8df2564"},{"byte_length":8406,"kind":"tex","path":"modules/LexLeanTarget/TargetSyntax.tex","sha256":"4e700f7b548f26e0d8b27cb03b236a6c4375296d6ef87c46619aaf19fc2b33fa"}],"project":"compiler","selection":["BudgetOracle","Certification","Gnaf","GnafCertificates","GnafFixtures","GradeOracle","Main","PlannerOracle","ReasoningFixtures","ReasoningOracle","RustSemantics","RustSyntax","ScreeningOracle","TargetFixtures","TargetOracle","TargetSemantics","TargetSyntax"],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","spec":"lexlean/build-manifest/1"} +{"build_id":"9b7ff20c8459ab3793dc388e4f7f3b8e471483a045e4fc1fd3ff215ffc3b7866","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"34a61de298b1122b118c12e65e88953a53855a8d7a23cfcdadbd2eafbaa54f85"},{"byte_length":643,"kind":"project-config","path":"lexlean.toml","sha256":"ef58478b65de0ad784269ab3513059f5afbb7f461bda9476efce78344301755e"},{"byte_length":4612,"kind":"source","path":"src/BudgetOracle.lex.tex","sha256":"c6545653dc603ec6710e038653686bd57e4b0e71fe362957cb0f0a5722898802"},{"byte_length":47895,"kind":"source","path":"src/Certification.lex.tex","sha256":"7e011c2fefdfd08c3f9d41a5cf5c891d72495aae7d4bc1e0b5d31a9d364c07fb"},{"byte_length":100847,"kind":"source","path":"src/Gnaf.lex.tex","sha256":"21b9c9174ae33fe77204e196a29a51463f2c9a400f7b305d33591c54f31d798d"},{"byte_length":105623,"kind":"source","path":"src/GnafCertificates.lex.tex","sha256":"498dafa5093f56f0a05bbddb58875aebc0769325386f2ca611f3a101d9368f64"},{"byte_length":680712,"kind":"source","path":"src/GnafFixtures.lex.tex","sha256":"e7f06e087d0ec40b8dd61f2fe1c51258ec55d93f5e5e16938c27598661e8d913"},{"byte_length":5030,"kind":"source","path":"src/GradeOracle.lex.tex","sha256":"1e19782f0fd76c6d49b5f7f5f29569f8f52b5d91397f0ec9921286cdd03b0fd0"},{"byte_length":811,"kind":"source","path":"src/Main.lex.tex","sha256":"a26d3c220ec1352dd96565ac2308c1684a945a98e1210b3dfaab30cd76dc1875"},{"byte_length":8685,"kind":"source","path":"src/PlannerOracle.lex.tex","sha256":"8579b13fcc26a5bdd3323388f400d1b0b805359f96fe4beea29b26bbaa79f50b"},{"byte_length":699968,"kind":"source","path":"src/ReasoningFixtures.lex.tex","sha256":"21de0c44ebce81bb7bb1b05a6e29815cc2e6c19a58a4c85459110bf3fd1dee9c"},{"byte_length":27419,"kind":"source","path":"src/ReasoningOracle.lex.tex","sha256":"7d5e680324c4fbffa4b8906aefe2e502d20994ff8cdaf223eb385e814bec77bb"},{"byte_length":103523,"kind":"source","path":"src/RustSemantics.lex.tex","sha256":"183644ea3d81403440add2ca225c82d462dde21a7c5a7928d2c313a12e9242b3"},{"byte_length":7619,"kind":"source","path":"src/RustSyntax.lex.tex","sha256":"9cbc4da6fc9441a03954f0979cbe4812aae0426811932e6ff1d6661043d3611f"},{"byte_length":3620,"kind":"source","path":"src/ScreeningOracle.lex.tex","sha256":"23fe7cb8804846c5418204184105f7381f5f36ddd2cdd1beec466416b5d12cb9"},{"byte_length":654074,"kind":"source","path":"src/TargetFixtures.lex.tex","sha256":"d746739ea3e78234f7a68280dc068d39b84f4064298a37383a8dc645bc188c27"},{"byte_length":2490,"kind":"source","path":"src/TargetOracle.lex.tex","sha256":"e34fca12090e04d8a853d4edfc9ae8db46d09ec586f2820f25d69c8ab3a7fb2d"},{"byte_length":426639,"kind":"source","path":"src/TargetSemantics.lex.tex","sha256":"92551ec717ba14a68c53203b5ea1f68359902201116de69c2816668038eb4a60"},{"byte_length":5518,"kind":"source","path":"src/TargetSyntax.lex.tex","sha256":"943d39daf9ece2d492cf8b15ba2df218f84031dbf0757b8ee765d240df55276e"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanTarget.BudgetOracle","module":"BudgetOracle","source_path":"src/BudgetOracle.lex.tex"},{"lean_module":"LexLeanTarget.Certification","module":"Certification","source_path":"src/Certification.lex.tex"},{"lean_module":"LexLeanTarget.Gnaf","module":"Gnaf","source_path":"src/Gnaf.lex.tex"},{"lean_module":"LexLeanTarget.GnafCertificates","module":"GnafCertificates","source_path":"src/GnafCertificates.lex.tex"},{"lean_module":"LexLeanTarget.GnafFixtures","module":"GnafFixtures","source_path":"src/GnafFixtures.lex.tex"},{"lean_module":"LexLeanTarget.GradeOracle","module":"GradeOracle","source_path":"src/GradeOracle.lex.tex"},{"lean_module":"LexLeanTarget.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"LexLeanTarget.PlannerOracle","module":"PlannerOracle","source_path":"src/PlannerOracle.lex.tex"},{"lean_module":"LexLeanTarget.ReasoningFixtures","module":"ReasoningFixtures","source_path":"src/ReasoningFixtures.lex.tex"},{"lean_module":"LexLeanTarget.ReasoningOracle","module":"ReasoningOracle","source_path":"src/ReasoningOracle.lex.tex"},{"lean_module":"LexLeanTarget.RustSemantics","module":"RustSemantics","source_path":"src/RustSemantics.lex.tex"},{"lean_module":"LexLeanTarget.RustSyntax","module":"RustSyntax","source_path":"src/RustSyntax.lex.tex"},{"lean_module":"LexLeanTarget.ScreeningOracle","module":"ScreeningOracle","source_path":"src/ScreeningOracle.lex.tex"},{"lean_module":"LexLeanTarget.TargetFixtures","module":"TargetFixtures","source_path":"src/TargetFixtures.lex.tex"},{"lean_module":"LexLeanTarget.TargetOracle","module":"TargetOracle","source_path":"src/TargetOracle.lex.tex"},{"lean_module":"LexLeanTarget.TargetSemantics","module":"TargetSemantics","source_path":"src/TargetSemantics.lex.tex"},{"lean_module":"LexLeanTarget.TargetSyntax","module":"TargetSyntax","source_path":"src/TargetSyntax.lex.tex"}],"outputs":[{"byte_length":11181,"kind":"coverage","path":"coverage/LexLeanTarget/BudgetOracle.coverage.json","sha256":"4c38c35c5f0cf117c7cfc0139ea1d78d74ba3687f38e2b90783bb5b92b6cd064"},{"byte_length":27889,"kind":"coverage","path":"coverage/LexLeanTarget/Certification.coverage.json","sha256":"d1fd9f61561ef5bf24e63f9909565eb91ae3ab75c0dcb99fe3d58c683536af92"},{"byte_length":49254,"kind":"coverage","path":"coverage/LexLeanTarget/Gnaf.coverage.json","sha256":"0d50115903a6801a603450a86c3916b027d999d99a86635329fb894f776f92ad"},{"byte_length":57711,"kind":"coverage","path":"coverage/LexLeanTarget/GnafCertificates.coverage.json","sha256":"11987f846c4397e765f1678df11775374c59d34dc8c5943d8929d71297760633"},{"byte_length":66645,"kind":"coverage","path":"coverage/LexLeanTarget/GnafFixtures.coverage.json","sha256":"bd9dab4cd246a183b9db20001c3b172ca748b474553f1bc30b14f6d0dda92734"},{"byte_length":10429,"kind":"coverage","path":"coverage/LexLeanTarget/GradeOracle.coverage.json","sha256":"394cf22f3967a4e544cb42caf7005a4c557bd63b56c465d58ad251179d555fc2"},{"byte_length":16662,"kind":"coverage","path":"coverage/LexLeanTarget/Main.coverage.json","sha256":"ac5e6c5061f44d9d2708be6a63546834eba79fecbb2230b0e3458c5af3c43989"},{"byte_length":15869,"kind":"coverage","path":"coverage/LexLeanTarget/PlannerOracle.coverage.json","sha256":"68fa5c011e011d56e6d0273084d5af91f1783d733ee710eab3a25b1a7cb4b391"},{"byte_length":34095,"kind":"coverage","path":"coverage/LexLeanTarget/ReasoningFixtures.coverage.json","sha256":"12c71e696f141058f795f256a1b658b73cbe5523fc418807ee163e4a8100b901"},{"byte_length":21934,"kind":"coverage","path":"coverage/LexLeanTarget/ReasoningOracle.coverage.json","sha256":"c4e1e0cc85511589d275588b731d2c0dea9ed3f9ad7f3a6dfb3804175767ed73"},{"byte_length":19509,"kind":"coverage","path":"coverage/LexLeanTarget/RustSemantics.coverage.json","sha256":"a1db132f98ddbcf22dc61de28715de5a4e328728ec2b47c0c626ba1d3dafde74"},{"byte_length":12534,"kind":"coverage","path":"coverage/LexLeanTarget/RustSyntax.coverage.json","sha256":"b3469906edbf88096e355b158222af2ff743d2b6c623562c452d152a9cf571c9"},{"byte_length":11293,"kind":"coverage","path":"coverage/LexLeanTarget/ScreeningOracle.coverage.json","sha256":"05a35bfd9204fc4711116a6323cfb3f9ce195f93a03523af68705039d8bbb068"},{"byte_length":101228,"kind":"coverage","path":"coverage/LexLeanTarget/TargetFixtures.coverage.json","sha256":"6624fc93ffffd63b7abc490cef8be822fa432ae5231488dbb57000faedecb56d"},{"byte_length":9389,"kind":"coverage","path":"coverage/LexLeanTarget/TargetOracle.coverage.json","sha256":"027cf182140446894d350ce94a425b754b854d31bfdd65c147fb4a8aa5f3ceef"},{"byte_length":17711,"kind":"coverage","path":"coverage/LexLeanTarget/TargetSemantics.coverage.json","sha256":"8c2275847f042368e2bed11862523e1c96d7cc4a56a66c954ab43f47ff9735a0"},{"byte_length":9810,"kind":"coverage","path":"coverage/LexLeanTarget/TargetSyntax.coverage.json","sha256":"6a2a365549546bf5b1ea4f2df51775ba3054c8be4e121c8594cf0868c5433524"},{"byte_length":63974,"kind":"lean","path":"modules/LexLeanTarget/BudgetOracle.lean","sha256":"33061e2080b80d31a3042e667c3f7ab7090051efcf5e67d5f0b4c384b1699cff"},{"byte_length":43091,"kind":"lean","path":"modules/LexLeanTarget/Certification.lean","sha256":"0484010f2efcdb78dd9bb28c7294d41f1587af73993e1f15466b1f372019ab6a"},{"byte_length":84874,"kind":"lean","path":"modules/LexLeanTarget/Gnaf.lean","sha256":"962a93bd8f993c56c9bdfafd527fe52c49a3868fc2180460ee11292f21898c9e"},{"byte_length":105947,"kind":"lean","path":"modules/LexLeanTarget/GnafCertificates.lean","sha256":"3fac84aa9e8110b50cc2cf24ff9d4f49d1a7b49a816137f43497b6c3c5e78f09"},{"byte_length":850353,"kind":"lean","path":"modules/LexLeanTarget/GnafFixtures.lean","sha256":"ca5db55769dfd1579762d2b5b6a004213895dbff0bb498dc10743d863d2a2315"},{"byte_length":44805,"kind":"lean","path":"modules/LexLeanTarget/GradeOracle.lean","sha256":"ea724bef2e4aafca56bc03452d8da8935c360841481997fc9b04bec7d205719f"},{"byte_length":1128,"kind":"lean","path":"modules/LexLeanTarget/Main.lean","sha256":"cb359700a417929e8ff9dbb35fd9ff41f0eda211b7c36009d7b7e92d7baeff13"},{"byte_length":171727,"kind":"lean","path":"modules/LexLeanTarget/PlannerOracle.lean","sha256":"a1590a1076cfca401cb1bfb72ca5b07363752f56ab4eae07f147d16b6d8e145c"},{"byte_length":896707,"kind":"lean","path":"modules/LexLeanTarget/ReasoningFixtures.lean","sha256":"cccf75a8f6c6d61da06a30177ab5001ec36132d16ee916d46c6d102d781a8d20"},{"byte_length":151030,"kind":"lean","path":"modules/LexLeanTarget/ReasoningOracle.lean","sha256":"ac78fb8128e5b859ed9b00bcfebdd57db1db0e3a1b9b95c54e92f6ecb77e17c1"},{"byte_length":86991,"kind":"lean","path":"modules/LexLeanTarget/RustSemantics.lean","sha256":"e19e285327ea0eead677ef40d4fb3a9d0b297570e432c4ee357af7a7abc9b6b9"},{"byte_length":4479,"kind":"lean","path":"modules/LexLeanTarget/RustSyntax.lean","sha256":"868130ffaf54b20c9941a5aa4f7020c4a2ee403f4ca5dc4624fd3199d50e4b54"},{"byte_length":45937,"kind":"lean","path":"modules/LexLeanTarget/ScreeningOracle.lean","sha256":"6e65882bc5d2591f8b4da728f510478a6aa621d92e718ab918cbec4c5327f368"},{"byte_length":802797,"kind":"lean","path":"modules/LexLeanTarget/TargetFixtures.lean","sha256":"2aa09bdc3b28620ffbf96e843d59c667ac7836c704951e95f7d14fcc93d56a9c"},{"byte_length":2355,"kind":"lean","path":"modules/LexLeanTarget/TargetOracle.lean","sha256":"473b7729d1679099d5b81865f794eff6a68308c9cfa3b0ca61d8d1c7eadfffc3"},{"byte_length":343014,"kind":"lean","path":"modules/LexLeanTarget/TargetSemantics.lean","sha256":"f8f6c6085c0dd1bbc8b6cd8fc49d4c3800e65c9c0033874c735341edef1291b9"},{"byte_length":2780,"kind":"lean","path":"modules/LexLeanTarget/TargetSyntax.lean","sha256":"c0e0bb061cfcdc7e7f4434e13fc8b7298dcb701db9ea8189e012d8068e04ee0c"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/BudgetOracle.closure.json","sha256":"77b793d6eeb5f55f9ee2676c6e61ecfcf8a47b1c7686bf8b5b82ed885098b3e5"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/Certification.closure.json","sha256":"14e70294074a52b88964920e91dbd1aec0c4ffe1d92a5c1d9e088a3cd3ae4630"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Gnaf.closure.json","sha256":"bf67edea690a60515a1852bd8ce58435814a28f3c729c184ed9e1416095dec25"},{"byte_length":10614,"kind":"lexicon-closure","path":"lexicons/GnafCertificates.closure.json","sha256":"091d8cfb8676ac6b1863e0ee193aca1dff96149c6174590d429cb663d3a26b2c"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/GnafFixtures.closure.json","sha256":"40c76800549e30b23ec113ded9ec8507304bc1b731f556d9ff2ffff6926aa97d"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/GradeOracle.closure.json","sha256":"b00cae435e73a9572c6db7dfd4591933c5a96e318ff62494abbb5083ecfd9a25"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/PlannerOracle.closure.json","sha256":"f29a6aa1f51c4b5482937e400c71fc118ef91bf1ddbc4076634f1ac32da50ca0"},{"byte_length":10615,"kind":"lexicon-closure","path":"lexicons/ReasoningFixtures.closure.json","sha256":"47757b8545a4270046b387e54f183e44288d14b5b5ae1e0b7a939731582d445e"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/ReasoningOracle.closure.json","sha256":"291571e44ca093a6966ef282b10abcfaff1a0e0ff6e909f543cbb16924dbdaec"},{"byte_length":10611,"kind":"lexicon-closure","path":"lexicons/RustSemantics.closure.json","sha256":"152f56877c9492f618bfc1eb44a6d8eb04d8ffb1e05c52f685a98efe173b9c6b"},{"byte_length":10608,"kind":"lexicon-closure","path":"lexicons/RustSyntax.closure.json","sha256":"d000985e33e8be7f26117319c5adb68380f9e7c44977c65e112e80472428cd79"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/ScreeningOracle.closure.json","sha256":"6653713be4bb8465a19c48088477644f2065431e1008ff3b9371401eaaa011f4"},{"byte_length":10612,"kind":"lexicon-closure","path":"lexicons/TargetFixtures.closure.json","sha256":"40cf03e3d335319ccbd3328e8eff2af5867f25d16c05d8f2303ff1ba414b57a1"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/TargetOracle.closure.json","sha256":"7834c4ed29b8d8fc6acd24325adba002e08e766d77f5b5a3e64afe6aab086b1f"},{"byte_length":10613,"kind":"lexicon-closure","path":"lexicons/TargetSemantics.closure.json","sha256":"5649cb299c72ad2bf7cd8ff70369be255cd0f52c7cc980807e6e1a7544f884c9"},{"byte_length":10610,"kind":"lexicon-closure","path":"lexicons/TargetSyntax.closure.json","sha256":"c1860f7ba449c93990d46c5f27eeeaabf17e319169e0a37fe21efc12999de2aa"},{"byte_length":6212,"kind":"map","path":"maps/LexLeanTarget/BudgetOracle.map.json","sha256":"1c1fc0d1a8813af2f0f8f9b515f0675fa5570c3049d95060bbb77a74c495770d"},{"byte_length":24054,"kind":"map","path":"maps/LexLeanTarget/Certification.map.json","sha256":"d6ba39d65c8883a812aa24db3a72d3f7801116c221479729da4a60320ee3fc1b"},{"byte_length":51466,"kind":"map","path":"maps/LexLeanTarget/Gnaf.map.json","sha256":"cf76f396a2b4582ed347fe5abfd31a69dc2a97d460d563e017c2f2332d0a3eaa"},{"byte_length":58783,"kind":"map","path":"maps/LexLeanTarget/GnafCertificates.map.json","sha256":"d23f9e5533365d9bb402f644f9b159305c9d76041df3911d23bf6853681369ea"},{"byte_length":72111,"kind":"map","path":"maps/LexLeanTarget/GnafFixtures.map.json","sha256":"c8792d9c364e06c40e0b77cc0c5e5876130d7f2485e1cf8072a8342ff6e64741"},{"byte_length":4588,"kind":"map","path":"maps/LexLeanTarget/GradeOracle.map.json","sha256":"a9192a5fe5b2dedae29fee2dcfbf99d9423e98f6684a91522b403afe4b3130a8"},{"byte_length":1352,"kind":"map","path":"maps/LexLeanTarget/Main.map.json","sha256":"d54fc2aa6b29103e53b5637e3f34bfdaa068a4357870ee5d03010255a1f00e5f"},{"byte_length":11761,"kind":"map","path":"maps/LexLeanTarget/PlannerOracle.map.json","sha256":"c37a1d2c8257def03d470caa2f83fe78b1e62de99e5eef20a15ffeaf0625b5ba"},{"byte_length":28320,"kind":"map","path":"maps/LexLeanTarget/ReasoningFixtures.map.json","sha256":"83feae52eaf4a6ec6e716de1036593644d599ba0677634dc779a1a7d8b70488f"},{"byte_length":19059,"kind":"map","path":"maps/LexLeanTarget/ReasoningOracle.map.json","sha256":"a3992c225c0536d7ee5b01b3bd700f089a07432246aaeae41f89bdd12d76118e"},{"byte_length":13888,"kind":"map","path":"maps/LexLeanTarget/RustSemantics.map.json","sha256":"a58af46a2b6091ef60fe7b31e9231c28d6e3a27e27f1af6e84eb9ae31f22cf9f"},{"byte_length":7165,"kind":"map","path":"maps/LexLeanTarget/RustSyntax.map.json","sha256":"0595cc88eca24864c625ce46002ec7bd46615e854eb096cd4527e2978bcdba78"},{"byte_length":6214,"kind":"map","path":"maps/LexLeanTarget/ScreeningOracle.map.json","sha256":"9cc9c20c6a6e66608e57206d9e495f4cc6019a43e8a3e28b234bb1897e76454f"},{"byte_length":114575,"kind":"map","path":"maps/LexLeanTarget/TargetFixtures.map.json","sha256":"8a1075b06ffbfc7c135cf0fef2d9925a6511304466d1e5d146865459f5b917cf"},{"byte_length":3299,"kind":"map","path":"maps/LexLeanTarget/TargetOracle.map.json","sha256":"f789db7d7681b2f3dc36d2709cbeeaaebf8b7dd33de7a58334b897501d68ccca"},{"byte_length":13138,"kind":"map","path":"maps/LexLeanTarget/TargetSemantics.map.json","sha256":"bb8bcb5da3abbd7bfdd62db5e99eaf8c4615437cc4098f883935c288f39acab9"},{"byte_length":4584,"kind":"map","path":"maps/LexLeanTarget/TargetSyntax.map.json","sha256":"1bb3f663b285c7a62bedec1dab744a043fe127dc1903d1a1edbb03326aa7715f"},{"byte_length":34987,"kind":"tex","path":"modules/LexLeanTarget/BudgetOracle.tex","sha256":"e119790e14fb08097a91884bd4d4576ecf25f73b8dfb77cb8a4a6974b9bd139c"},{"byte_length":57133,"kind":"tex","path":"modules/LexLeanTarget/Certification.tex","sha256":"cbed4c0f6e9999f341c5b6d0a46956f21c506c0a3c04512328ae53aa864c6a2e"},{"byte_length":111707,"kind":"tex","path":"modules/LexLeanTarget/Gnaf.tex","sha256":"f0af7a2df200270323f7d392f404b19a93ee74aa973bf12353a519fd9783dbfa"},{"byte_length":132342,"kind":"tex","path":"modules/LexLeanTarget/GnafCertificates.tex","sha256":"b48420c115ae3fa7c592a3ae5fdf9700f65605c7b1697a139c3791e8ff5506f5"},{"byte_length":885281,"kind":"tex","path":"modules/LexLeanTarget/GnafFixtures.tex","sha256":"fe73187797328af446b1920f7895621b6c16a8d2a0874484d163ab5c5ac99722"},{"byte_length":26691,"kind":"tex","path":"modules/LexLeanTarget/GradeOracle.tex","sha256":"660efcdb6b42661eab9deb5d35f2533182161e1126453b76403d0803ae92ac04"},{"byte_length":532,"kind":"tex","path":"modules/LexLeanTarget/Main.tex","sha256":"fb9b15c8eb40ef1542e9d69a6a3a8e9c242855157699cff8453d8c44becc08ec"},{"byte_length":90367,"kind":"tex","path":"modules/LexLeanTarget/PlannerOracle.tex","sha256":"1517be188348a5e8c29ecac93545fa4ac2338e802a7a030bfec7ccc6fb5317f1"},{"byte_length":912884,"kind":"tex","path":"modules/LexLeanTarget/ReasoningFixtures.tex","sha256":"2e3f3cf3328aebec9f71f3b003e371e2f4747156548f4157e26e84d502baac63"},{"byte_length":78159,"kind":"tex","path":"modules/LexLeanTarget/ReasoningOracle.tex","sha256":"9f22e4e59d2b2515287ca787c5bbef1669441372e69d090b8dbfbc4182088896"},{"byte_length":94786,"kind":"tex","path":"modules/LexLeanTarget/RustSemantics.tex","sha256":"49c608b1f2220836d6ddbdd204a91e44cdf44eb75c3a1b12c809d3236a65496e"},{"byte_length":11151,"kind":"tex","path":"modules/LexLeanTarget/RustSyntax.tex","sha256":"6e51a9b399de99a2a43a5742ba9f6d6203055e0c84fe5a39dbe1c03a264c0511"},{"byte_length":27194,"kind":"tex","path":"modules/LexLeanTarget/ScreeningOracle.tex","sha256":"dd053d08d2811509a8659e75b228530b5bff859bb749a955297b965407bf13e4"},{"byte_length":859771,"kind":"tex","path":"modules/LexLeanTarget/TargetFixtures.tex","sha256":"d81cf82e55307a02d34c830cb4e1101cb1c5b2accff59f66cb1836cf186a3de0"},{"byte_length":3601,"kind":"tex","path":"modules/LexLeanTarget/TargetOracle.tex","sha256":"3ac498bbc1902427cc192481895d2370cfb70bc2e5242ecb90ff8e29cb2edb48"},{"byte_length":353998,"kind":"tex","path":"modules/LexLeanTarget/TargetSemantics.tex","sha256":"126ab7711ed907166c1c788f0a3b63535938e5d26ca2666243dacd81b8df2564"},{"byte_length":8406,"kind":"tex","path":"modules/LexLeanTarget/TargetSyntax.tex","sha256":"4e700f7b548f26e0d8b27cb03b236a6c4375296d6ef87c46619aaf19fc2b33fa"}],"project":"compiler","selection":["BudgetOracle","Certification","Gnaf","GnafCertificates","GnafFixtures","GradeOracle","Main","PlannerOracle","ReasoningFixtures","ReasoningOracle","RustSemantics","RustSyntax","ScreeningOracle","TargetFixtures","TargetOracle","TargetSemantics","TargetSyntax"],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","spec":"lexlean/build-manifest/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/BudgetOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/BudgetOracle.map.json index 39c3aa6c5..15b2f0313 100644 --- a/compiler/expected/build/maps/LexLeanTarget/BudgetOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/BudgetOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/BudgetOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/BudgetOracle.tex"}],"mappings":[{"artifact":0,"gen_end":361,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":0,"gen_end":504,"gen_start":361,"node":1,"role":"declaration","source":0,"src_end":300,"src_start":121},{"artifact":0,"gen_end":585,"gen_start":504,"node":2,"role":"declaration","source":0,"src_end":424,"src_start":302},{"artifact":0,"gen_end":586,"gen_start":585,"node":3,"role":"declaration","source":0,"src_end":564,"src_start":426},{"artifact":0,"gen_end":3695,"gen_start":586,"node":4,"role":"declaration","source":0,"src_end":843,"src_start":566},{"artifact":0,"gen_end":6833,"gen_start":3695,"node":5,"role":"declaration","source":0,"src_end":1154,"src_start":845},{"artifact":0,"gen_end":8270,"gen_start":6833,"node":6,"role":"declaration","source":0,"src_end":1458,"src_start":1156},{"artifact":0,"gen_end":11412,"gen_start":8270,"node":7,"role":"declaration","source":0,"src_end":1761,"src_start":1460},{"artifact":0,"gen_end":14583,"gen_start":11412,"node":8,"role":"declaration","source":0,"src_end":2096,"src_start":1763},{"artifact":0,"gen_end":16253,"gen_start":14583,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":2098},{"artifact":0,"gen_end":16340,"gen_start":16253,"node":10,"role":"declaration","source":0,"src_end":2608,"src_start":2491},{"artifact":0,"gen_end":16431,"gen_start":16340,"node":11,"role":"declaration","source":0,"src_end":2753,"src_start":2610},{"artifact":0,"gen_end":19498,"gen_start":16431,"node":12,"role":"declaration","source":0,"src_end":2992,"src_start":2755},{"artifact":0,"gen_end":19703,"gen_start":19498,"node":13,"role":"declaration","source":0,"src_end":3200,"src_start":2994},{"artifact":0,"gen_end":22769,"gen_start":19703,"node":14,"role":"declaration","source":0,"src_end":3461,"src_start":3202},{"artifact":0,"gen_end":44710,"gen_start":22769,"node":15,"role":"declaration","source":0,"src_end":4034,"src_start":3463},{"artifact":0,"gen_end":63942,"gen_start":44710,"node":16,"role":"declaration","source":0,"src_end":4576,"src_start":4036},{"artifact":0,"gen_end":63974,"gen_start":63942,"node":0,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":1,"gen_end":497,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":300,"src_start":121},{"artifact":1,"gen_end":794,"gen_start":497,"node":19,"role":"declaration","source":0,"src_end":424,"src_start":302},{"artifact":1,"gen_end":1045,"gen_start":794,"node":20,"role":"declaration","source":0,"src_end":564,"src_start":426},{"artifact":1,"gen_end":1428,"gen_start":1045,"node":21,"role":"declaration","source":0,"src_end":843,"src_start":566},{"artifact":1,"gen_end":1836,"gen_start":1428,"node":22,"role":"declaration","source":0,"src_end":1154,"src_start":845},{"artifact":1,"gen_end":3715,"gen_start":1836,"node":23,"role":"declaration","source":0,"src_end":1458,"src_start":1156},{"artifact":1,"gen_end":4133,"gen_start":3715,"node":24,"role":"declaration","source":0,"src_end":1761,"src_start":1460},{"artifact":1,"gen_end":4576,"gen_start":4133,"node":25,"role":"declaration","source":0,"src_end":2096,"src_start":1763},{"artifact":1,"gen_end":6863,"gen_start":4576,"node":26,"role":"declaration","source":0,"src_end":2489,"src_start":2098},{"artifact":1,"gen_end":7154,"gen_start":6863,"node":27,"role":"declaration","source":0,"src_end":2608,"src_start":2491},{"artifact":1,"gen_end":7525,"gen_start":7154,"node":28,"role":"declaration","source":0,"src_end":2753,"src_start":2610},{"artifact":1,"gen_end":7842,"gen_start":7525,"node":29,"role":"declaration","source":0,"src_end":2992,"src_start":2755},{"artifact":1,"gen_end":8490,"gen_start":7842,"node":30,"role":"declaration","source":0,"src_end":3200,"src_start":2994},{"artifact":1,"gen_end":8826,"gen_start":8490,"node":31,"role":"declaration","source":0,"src_end":3461,"src_start":3202},{"artifact":1,"gen_end":22640,"gen_start":8826,"node":32,"role":"declaration","source":0,"src_end":4034,"src_start":3463},{"artifact":1,"gen_end":34972,"gen_start":22640,"node":33,"role":"declaration","source":0,"src_end":4576,"src_start":4036},{"artifact":1,"gen_end":34987,"gen_start":34972,"node":17,"role":"declaration","source":0,"src_end":4612,"src_start":0}],"module":"BudgetOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/BudgetOracle.lex.tex","sha256":"c6545653dc603ec6710e038653686bd57e4b0e71fe362957cb0f0a5722898802"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/BudgetOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/BudgetOracle.tex"}],"mappings":[{"artifact":0,"gen_end":361,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":0,"gen_end":504,"gen_start":361,"node":1,"role":"declaration","source":0,"src_end":300,"src_start":121},{"artifact":0,"gen_end":585,"gen_start":504,"node":2,"role":"declaration","source":0,"src_end":424,"src_start":302},{"artifact":0,"gen_end":586,"gen_start":585,"node":3,"role":"declaration","source":0,"src_end":564,"src_start":426},{"artifact":0,"gen_end":3695,"gen_start":586,"node":4,"role":"declaration","source":0,"src_end":843,"src_start":566},{"artifact":0,"gen_end":6833,"gen_start":3695,"node":5,"role":"declaration","source":0,"src_end":1154,"src_start":845},{"artifact":0,"gen_end":8270,"gen_start":6833,"node":6,"role":"declaration","source":0,"src_end":1458,"src_start":1156},{"artifact":0,"gen_end":11412,"gen_start":8270,"node":7,"role":"declaration","source":0,"src_end":1761,"src_start":1460},{"artifact":0,"gen_end":14583,"gen_start":11412,"node":8,"role":"declaration","source":0,"src_end":2096,"src_start":1763},{"artifact":0,"gen_end":16253,"gen_start":14583,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":2098},{"artifact":0,"gen_end":16340,"gen_start":16253,"node":10,"role":"declaration","source":0,"src_end":2608,"src_start":2491},{"artifact":0,"gen_end":16431,"gen_start":16340,"node":11,"role":"declaration","source":0,"src_end":2753,"src_start":2610},{"artifact":0,"gen_end":19498,"gen_start":16431,"node":12,"role":"declaration","source":0,"src_end":2992,"src_start":2755},{"artifact":0,"gen_end":19703,"gen_start":19498,"node":13,"role":"declaration","source":0,"src_end":3200,"src_start":2994},{"artifact":0,"gen_end":22769,"gen_start":19703,"node":14,"role":"declaration","source":0,"src_end":3461,"src_start":3202},{"artifact":0,"gen_end":44710,"gen_start":22769,"node":15,"role":"declaration","source":0,"src_end":4034,"src_start":3463},{"artifact":0,"gen_end":63942,"gen_start":44710,"node":16,"role":"declaration","source":0,"src_end":4576,"src_start":4036},{"artifact":0,"gen_end":63974,"gen_start":63942,"node":0,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":4612,"src_start":0},{"artifact":1,"gen_end":497,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":300,"src_start":121},{"artifact":1,"gen_end":794,"gen_start":497,"node":19,"role":"declaration","source":0,"src_end":424,"src_start":302},{"artifact":1,"gen_end":1045,"gen_start":794,"node":20,"role":"declaration","source":0,"src_end":564,"src_start":426},{"artifact":1,"gen_end":1428,"gen_start":1045,"node":21,"role":"declaration","source":0,"src_end":843,"src_start":566},{"artifact":1,"gen_end":1836,"gen_start":1428,"node":22,"role":"declaration","source":0,"src_end":1154,"src_start":845},{"artifact":1,"gen_end":3715,"gen_start":1836,"node":23,"role":"declaration","source":0,"src_end":1458,"src_start":1156},{"artifact":1,"gen_end":4133,"gen_start":3715,"node":24,"role":"declaration","source":0,"src_end":1761,"src_start":1460},{"artifact":1,"gen_end":4576,"gen_start":4133,"node":25,"role":"declaration","source":0,"src_end":2096,"src_start":1763},{"artifact":1,"gen_end":6863,"gen_start":4576,"node":26,"role":"declaration","source":0,"src_end":2489,"src_start":2098},{"artifact":1,"gen_end":7154,"gen_start":6863,"node":27,"role":"declaration","source":0,"src_end":2608,"src_start":2491},{"artifact":1,"gen_end":7525,"gen_start":7154,"node":28,"role":"declaration","source":0,"src_end":2753,"src_start":2610},{"artifact":1,"gen_end":7842,"gen_start":7525,"node":29,"role":"declaration","source":0,"src_end":2992,"src_start":2755},{"artifact":1,"gen_end":8490,"gen_start":7842,"node":30,"role":"declaration","source":0,"src_end":3200,"src_start":2994},{"artifact":1,"gen_end":8826,"gen_start":8490,"node":31,"role":"declaration","source":0,"src_end":3461,"src_start":3202},{"artifact":1,"gen_end":22640,"gen_start":8826,"node":32,"role":"declaration","source":0,"src_end":4034,"src_start":3463},{"artifact":1,"gen_end":34972,"gen_start":22640,"node":33,"role":"declaration","source":0,"src_end":4576,"src_start":4036},{"artifact":1,"gen_end":34987,"gen_start":34972,"node":17,"role":"declaration","source":0,"src_end":4612,"src_start":0}],"module":"BudgetOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/BudgetOracle.lex.tex","sha256":"c6545653dc603ec6710e038653686bd57e4b0e71fe362957cb0f0a5722898802"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/Certification.map.json b/compiler/expected/build/maps/LexLeanTarget/Certification.map.json index 0bdf6edef..2b4a95716 100644 --- a/compiler/expected/build/maps/LexLeanTarget/Certification.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/Certification.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Certification.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Certification.tex"}],"mappings":[{"artifact":0,"gen_end":366,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":0,"gen_end":450,"gen_start":366,"node":1,"role":"declaration","source":0,"src_end":407,"src_start":201},{"artifact":0,"gen_end":576,"gen_start":450,"node":2,"role":"declaration","source":0,"src_end":657,"src_start":409},{"artifact":0,"gen_end":636,"gen_start":576,"node":3,"role":"declaration","source":0,"src_end":792,"src_start":659},{"artifact":0,"gen_end":832,"gen_start":636,"node":4,"role":"declaration","source":0,"src_end":1116,"src_start":794},{"artifact":0,"gen_end":1074,"gen_start":832,"node":5,"role":"declaration","source":0,"src_end":1482,"src_start":1118},{"artifact":0,"gen_end":1235,"gen_start":1074,"node":6,"role":"declaration","source":0,"src_end":1799,"src_start":1484},{"artifact":0,"gen_end":1500,"gen_start":1235,"node":7,"role":"declaration","source":0,"src_end":2280,"src_start":1801},{"artifact":0,"gen_end":2160,"gen_start":1500,"node":8,"role":"declaration","source":0,"src_end":3365,"src_start":2282},{"artifact":0,"gen_end":2337,"gen_start":2160,"node":9,"role":"declaration","source":0,"src_end":3651,"src_start":3367},{"artifact":0,"gen_end":2478,"gen_start":2337,"node":10,"role":"declaration","source":0,"src_end":3885,"src_start":3653},{"artifact":0,"gen_end":2616,"gen_start":2478,"node":11,"role":"declaration","source":0,"src_end":4121,"src_start":3887},{"artifact":0,"gen_end":2989,"gen_start":2616,"node":12,"role":"declaration","source":0,"src_end":4517,"src_start":4123},{"artifact":0,"gen_end":3302,"gen_start":2989,"node":13,"role":"declaration","source":0,"src_end":4914,"src_start":4519},{"artifact":0,"gen_end":3619,"gen_start":3302,"node":14,"role":"declaration","source":0,"src_end":5325,"src_start":4916},{"artifact":0,"gen_end":3878,"gen_start":3619,"node":15,"role":"declaration","source":0,"src_end":5674,"src_start":5327},{"artifact":0,"gen_end":4133,"gen_start":3878,"node":16,"role":"declaration","source":0,"src_end":6017,"src_start":5676},{"artifact":0,"gen_end":4677,"gen_start":4133,"node":17,"role":"declaration","source":0,"src_end":6519,"src_start":6019},{"artifact":0,"gen_end":4884,"gen_start":4677,"node":18,"role":"declaration","source":0,"src_end":6783,"src_start":6521},{"artifact":0,"gen_end":5084,"gen_start":4884,"node":19,"role":"declaration","source":0,"src_end":7039,"src_start":6785},{"artifact":0,"gen_end":6370,"gen_start":5084,"node":20,"role":"declaration","source":0,"src_end":8308,"src_start":7041},{"artifact":0,"gen_end":7715,"gen_start":6370,"node":21,"role":"declaration","source":0,"src_end":9621,"src_start":8310},{"artifact":0,"gen_end":9057,"gen_start":7715,"node":22,"role":"declaration","source":0,"src_end":10932,"src_start":9623},{"artifact":0,"gen_end":9280,"gen_start":9057,"node":23,"role":"declaration","source":0,"src_end":11199,"src_start":10934},{"artifact":0,"gen_end":9510,"gen_start":9280,"node":24,"role":"declaration","source":0,"src_end":11473,"src_start":11201},{"artifact":0,"gen_end":9731,"gen_start":9510,"node":25,"role":"declaration","source":0,"src_end":11738,"src_start":11475},{"artifact":0,"gen_end":11171,"gen_start":9731,"node":26,"role":"declaration","source":0,"src_end":13152,"src_start":11740},{"artifact":0,"gen_end":11419,"gen_start":11171,"node":27,"role":"declaration","source":0,"src_end":13455,"src_start":13154},{"artifact":0,"gen_end":11642,"gen_start":11419,"node":28,"role":"declaration","source":0,"src_end":13733,"src_start":13457},{"artifact":0,"gen_end":11847,"gen_start":11642,"node":29,"role":"declaration","source":0,"src_end":13990,"src_start":13735},{"artifact":0,"gen_end":12046,"gen_start":11847,"node":30,"role":"declaration","source":0,"src_end":14270,"src_start":13992},{"artifact":0,"gen_end":12880,"gen_start":12046,"node":31,"role":"declaration","source":0,"src_end":15243,"src_start":14272},{"artifact":0,"gen_end":13469,"gen_start":12880,"node":32,"role":"declaration","source":0,"src_end":15856,"src_start":15245},{"artifact":0,"gen_end":13799,"gen_start":13469,"node":33,"role":"declaration","source":0,"src_end":16150,"src_start":15858},{"artifact":0,"gen_end":14284,"gen_start":13799,"node":34,"role":"declaration","source":0,"src_end":16581,"src_start":16152},{"artifact":0,"gen_end":14785,"gen_start":14284,"node":35,"role":"declaration","source":0,"src_end":17058,"src_start":16583},{"artifact":0,"gen_end":15152,"gen_start":14785,"node":36,"role":"declaration","source":0,"src_end":17427,"src_start":17060},{"artifact":0,"gen_end":17284,"gen_start":15152,"node":37,"role":"declaration","source":0,"src_end":19582,"src_start":17429},{"artifact":0,"gen_end":17926,"gen_start":17284,"node":38,"role":"declaration","source":0,"src_end":20233,"src_start":19584},{"artifact":0,"gen_end":18209,"gen_start":17926,"node":39,"role":"declaration","source":0,"src_end":20543,"src_start":20235},{"artifact":0,"gen_end":18829,"gen_start":18209,"node":40,"role":"declaration","source":0,"src_end":21235,"src_start":20545},{"artifact":0,"gen_end":19203,"gen_start":18829,"node":41,"role":"declaration","source":0,"src_end":21620,"src_start":21237},{"artifact":0,"gen_end":19619,"gen_start":19203,"node":42,"role":"declaration","source":0,"src_end":22028,"src_start":21622},{"artifact":0,"gen_end":20067,"gen_start":19619,"node":43,"role":"declaration","source":0,"src_end":22454,"src_start":22030},{"artifact":0,"gen_end":20548,"gen_start":20067,"node":44,"role":"declaration","source":0,"src_end":22889,"src_start":22456},{"artifact":0,"gen_end":21205,"gen_start":20548,"node":45,"role":"declaration","source":0,"src_end":23509,"src_start":22891},{"artifact":0,"gen_end":21862,"gen_start":21205,"node":46,"role":"declaration","source":0,"src_end":24129,"src_start":23511},{"artifact":0,"gen_end":22174,"gen_start":21862,"node":47,"role":"declaration","source":0,"src_end":24502,"src_start":24131},{"artifact":0,"gen_end":22484,"gen_start":22174,"node":48,"role":"declaration","source":0,"src_end":24873,"src_start":24504},{"artifact":0,"gen_end":22923,"gen_start":22484,"node":49,"role":"declaration","source":0,"src_end":25355,"src_start":24875},{"artifact":0,"gen_end":23733,"gen_start":22923,"node":50,"role":"declaration","source":0,"src_end":26212,"src_start":25357},{"artifact":0,"gen_end":24375,"gen_start":23733,"node":51,"role":"declaration","source":0,"src_end":26941,"src_start":26214},{"artifact":0,"gen_end":24887,"gen_start":24375,"node":52,"role":"declaration","source":0,"src_end":27477,"src_start":26943},{"artifact":0,"gen_end":26207,"gen_start":24887,"node":53,"role":"declaration","source":0,"src_end":29190,"src_start":27479},{"artifact":0,"gen_end":26746,"gen_start":26207,"node":54,"role":"declaration","source":0,"src_end":29753,"src_start":29192},{"artifact":0,"gen_end":27355,"gen_start":26746,"node":55,"role":"declaration","source":0,"src_end":30529,"src_start":29755},{"artifact":0,"gen_end":28115,"gen_start":27355,"node":56,"role":"declaration","source":0,"src_end":31375,"src_start":30531},{"artifact":0,"gen_end":29541,"gen_start":28115,"node":57,"role":"declaration","source":0,"src_end":33169,"src_start":31377},{"artifact":0,"gen_end":30079,"gen_start":29541,"node":58,"role":"declaration","source":0,"src_end":33739,"src_start":33171},{"artifact":0,"gen_end":30806,"gen_start":30079,"node":59,"role":"declaration","source":0,"src_end":34548,"src_start":33741},{"artifact":0,"gen_end":31453,"gen_start":30806,"node":60,"role":"declaration","source":0,"src_end":35508,"src_start":34550},{"artifact":0,"gen_end":32255,"gen_start":31453,"node":61,"role":"declaration","source":0,"src_end":36352,"src_start":35510},{"artifact":0,"gen_end":33068,"gen_start":32255,"node":62,"role":"declaration","source":0,"src_end":37402,"src_start":36354},{"artifact":0,"gen_end":33378,"gen_start":33068,"node":63,"role":"declaration","source":0,"src_end":37757,"src_start":37404},{"artifact":0,"gen_end":33951,"gen_start":33378,"node":64,"role":"declaration","source":0,"src_end":38410,"src_start":37759},{"artifact":0,"gen_end":35798,"gen_start":33951,"node":65,"role":"declaration","source":0,"src_end":40615,"src_start":38412},{"artifact":0,"gen_end":37108,"gen_start":35798,"node":66,"role":"declaration","source":0,"src_end":42146,"src_start":40617},{"artifact":0,"gen_end":38939,"gen_start":37108,"node":67,"role":"declaration","source":0,"src_end":43756,"src_start":42148},{"artifact":0,"gen_end":39386,"gen_start":38939,"node":68,"role":"declaration","source":0,"src_end":44146,"src_start":43758},{"artifact":0,"gen_end":40167,"gen_start":39386,"node":69,"role":"declaration","source":0,"src_end":44821,"src_start":44148},{"artifact":0,"gen_end":43058,"gen_start":40167,"node":70,"role":"declaration","source":0,"src_end":47859,"src_start":44823},{"artifact":0,"gen_end":43091,"gen_start":43058,"node":0,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":71,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":1,"gen_end":392,"gen_start":134,"node":72,"role":"declaration","source":0,"src_end":407,"src_start":201},{"artifact":1,"gen_end":716,"gen_start":392,"node":73,"role":"declaration","source":0,"src_end":657,"src_start":409},{"artifact":1,"gen_end":887,"gen_start":716,"node":74,"role":"declaration","source":0,"src_end":792,"src_start":659},{"artifact":1,"gen_end":1309,"gen_start":887,"node":75,"role":"declaration","source":0,"src_end":1116,"src_start":794},{"artifact":1,"gen_end":1838,"gen_start":1309,"node":76,"role":"declaration","source":0,"src_end":1482,"src_start":1118},{"artifact":1,"gen_end":2277,"gen_start":1838,"node":77,"role":"declaration","source":0,"src_end":1799,"src_start":1484},{"artifact":1,"gen_end":2965,"gen_start":2277,"node":78,"role":"declaration","source":0,"src_end":2280,"src_start":1801},{"artifact":1,"gen_end":4556,"gen_start":2965,"node":79,"role":"declaration","source":0,"src_end":3365,"src_start":2282},{"artifact":1,"gen_end":4916,"gen_start":4556,"node":80,"role":"declaration","source":0,"src_end":3651,"src_start":3367},{"artifact":1,"gen_end":5200,"gen_start":4916,"node":81,"role":"declaration","source":0,"src_end":3885,"src_start":3653},{"artifact":1,"gen_end":5486,"gen_start":5200,"node":82,"role":"declaration","source":0,"src_end":4121,"src_start":3887},{"artifact":1,"gen_end":6020,"gen_start":5486,"node":83,"role":"declaration","source":0,"src_end":4517,"src_start":4123},{"artifact":1,"gen_end":6512,"gen_start":6020,"node":84,"role":"declaration","source":0,"src_end":4914,"src_start":4519},{"artifact":1,"gen_end":7008,"gen_start":6512,"node":85,"role":"declaration","source":0,"src_end":5325,"src_start":4916},{"artifact":1,"gen_end":7446,"gen_start":7008,"node":86,"role":"declaration","source":0,"src_end":5674,"src_start":5327},{"artifact":1,"gen_end":7880,"gen_start":7446,"node":87,"role":"declaration","source":0,"src_end":6017,"src_start":5676},{"artifact":1,"gen_end":8578,"gen_start":7880,"node":88,"role":"declaration","source":0,"src_end":6519,"src_start":6019},{"artifact":1,"gen_end":8970,"gen_start":8578,"node":89,"role":"declaration","source":0,"src_end":6783,"src_start":6521},{"artifact":1,"gen_end":9355,"gen_start":8970,"node":90,"role":"declaration","source":0,"src_end":7039,"src_start":6785},{"artifact":1,"gen_end":10846,"gen_start":9355,"node":91,"role":"declaration","source":0,"src_end":8308,"src_start":7041},{"artifact":1,"gen_end":12396,"gen_start":10846,"node":92,"role":"declaration","source":0,"src_end":9621,"src_start":8310},{"artifact":1,"gen_end":13943,"gen_start":12396,"node":93,"role":"declaration","source":0,"src_end":10932,"src_start":9623},{"artifact":1,"gen_end":14348,"gen_start":13943,"node":94,"role":"declaration","source":0,"src_end":11199,"src_start":10934},{"artifact":1,"gen_end":14760,"gen_start":14348,"node":95,"role":"declaration","source":0,"src_end":11473,"src_start":11201},{"artifact":1,"gen_end":15163,"gen_start":14760,"node":96,"role":"declaration","source":0,"src_end":11738,"src_start":11475},{"artifact":1,"gen_end":16894,"gen_start":15163,"node":97,"role":"declaration","source":0,"src_end":13152,"src_start":11740},{"artifact":1,"gen_end":17397,"gen_start":16894,"node":98,"role":"declaration","source":0,"src_end":13455,"src_start":13154},{"artifact":1,"gen_end":17875,"gen_start":17397,"node":99,"role":"declaration","source":0,"src_end":13733,"src_start":13457},{"artifact":1,"gen_end":18335,"gen_start":17875,"node":100,"role":"declaration","source":0,"src_end":13990,"src_start":13735},{"artifact":1,"gen_end":18733,"gen_start":18335,"node":101,"role":"declaration","source":0,"src_end":14270,"src_start":13992},{"artifact":1,"gen_end":19757,"gen_start":18733,"node":102,"role":"declaration","source":0,"src_end":15243,"src_start":14272},{"artifact":1,"gen_end":20533,"gen_start":19757,"node":103,"role":"declaration","source":0,"src_end":15856,"src_start":15245},{"artifact":1,"gen_end":21045,"gen_start":20533,"node":104,"role":"declaration","source":0,"src_end":16150,"src_start":15858},{"artifact":1,"gen_end":21712,"gen_start":21045,"node":105,"role":"declaration","source":0,"src_end":16581,"src_start":16152},{"artifact":1,"gen_end":22399,"gen_start":21712,"node":106,"role":"declaration","source":0,"src_end":17058,"src_start":16583},{"artifact":1,"gen_end":22952,"gen_start":22399,"node":107,"role":"declaration","source":0,"src_end":17427,"src_start":17060},{"artifact":1,"gen_end":25312,"gen_start":22952,"node":108,"role":"declaration","source":0,"src_end":19582,"src_start":17429},{"artifact":1,"gen_end":26114,"gen_start":25312,"node":109,"role":"declaration","source":0,"src_end":20233,"src_start":19584},{"artifact":1,"gen_end":26576,"gen_start":26114,"node":110,"role":"declaration","source":0,"src_end":20543,"src_start":20235},{"artifact":1,"gen_end":27372,"gen_start":26576,"node":111,"role":"declaration","source":0,"src_end":21235,"src_start":20545},{"artifact":1,"gen_end":27920,"gen_start":27372,"node":112,"role":"declaration","source":0,"src_end":21620,"src_start":21237},{"artifact":1,"gen_end":28559,"gen_start":27920,"node":113,"role":"declaration","source":0,"src_end":22028,"src_start":21622},{"artifact":1,"gen_end":29193,"gen_start":28559,"node":114,"role":"declaration","source":0,"src_end":22454,"src_start":22030},{"artifact":1,"gen_end":29858,"gen_start":29193,"node":115,"role":"declaration","source":0,"src_end":22889,"src_start":22456},{"artifact":1,"gen_end":30655,"gen_start":29858,"node":116,"role":"declaration","source":0,"src_end":23509,"src_start":22891},{"artifact":1,"gen_end":31452,"gen_start":30655,"node":117,"role":"declaration","source":0,"src_end":24129,"src_start":23511},{"artifact":1,"gen_end":31987,"gen_start":31452,"node":118,"role":"declaration","source":0,"src_end":24502,"src_start":24131},{"artifact":1,"gen_end":32520,"gen_start":31987,"node":119,"role":"declaration","source":0,"src_end":24873,"src_start":24504},{"artifact":1,"gen_end":33186,"gen_start":32520,"node":120,"role":"declaration","source":0,"src_end":25355,"src_start":24875},{"artifact":1,"gen_end":34220,"gen_start":33186,"node":121,"role":"declaration","source":0,"src_end":26212,"src_start":25357},{"artifact":1,"gen_end":35040,"gen_start":34220,"node":122,"role":"declaration","source":0,"src_end":26941,"src_start":26214},{"artifact":1,"gen_end":35776,"gen_start":35040,"node":123,"role":"declaration","source":0,"src_end":27477,"src_start":26943},{"artifact":1,"gen_end":37283,"gen_start":35776,"node":124,"role":"declaration","source":0,"src_end":29190,"src_start":27479},{"artifact":1,"gen_end":37931,"gen_start":37283,"node":125,"role":"declaration","source":0,"src_end":29753,"src_start":29192},{"artifact":1,"gen_end":38726,"gen_start":37931,"node":126,"role":"declaration","source":0,"src_end":30529,"src_start":29755},{"artifact":1,"gen_end":39672,"gen_start":38726,"node":127,"role":"declaration","source":0,"src_end":31375,"src_start":30531},{"artifact":1,"gen_end":41284,"gen_start":39672,"node":128,"role":"declaration","source":0,"src_end":33169,"src_start":31377},{"artifact":1,"gen_end":41945,"gen_start":41284,"node":129,"role":"declaration","source":0,"src_end":33739,"src_start":33171},{"artifact":1,"gen_end":42858,"gen_start":41945,"node":130,"role":"declaration","source":0,"src_end":34548,"src_start":33741},{"artifact":1,"gen_end":43683,"gen_start":42858,"node":131,"role":"declaration","source":0,"src_end":35508,"src_start":34550},{"artifact":1,"gen_end":44669,"gen_start":43683,"node":132,"role":"declaration","source":0,"src_end":36352,"src_start":35510},{"artifact":1,"gen_end":45667,"gen_start":44669,"node":133,"role":"declaration","source":0,"src_end":37402,"src_start":36354},{"artifact":1,"gen_end":46132,"gen_start":45667,"node":134,"role":"declaration","source":0,"src_end":37757,"src_start":37404},{"artifact":1,"gen_end":46840,"gen_start":46132,"node":135,"role":"declaration","source":0,"src_end":38410,"src_start":37759},{"artifact":1,"gen_end":48872,"gen_start":46840,"node":136,"role":"declaration","source":0,"src_end":40615,"src_start":38412},{"artifact":1,"gen_end":50367,"gen_start":48872,"node":137,"role":"declaration","source":0,"src_end":42146,"src_start":40617},{"artifact":1,"gen_end":52385,"gen_start":50367,"node":138,"role":"declaration","source":0,"src_end":43756,"src_start":42148},{"artifact":1,"gen_end":53014,"gen_start":52385,"node":139,"role":"declaration","source":0,"src_end":44146,"src_start":43758},{"artifact":1,"gen_end":53977,"gen_start":53014,"node":140,"role":"declaration","source":0,"src_end":44821,"src_start":44148},{"artifact":1,"gen_end":57118,"gen_start":53977,"node":141,"role":"declaration","source":0,"src_end":47859,"src_start":44823},{"artifact":1,"gen_end":57133,"gen_start":57118,"node":71,"role":"declaration","source":0,"src_end":47895,"src_start":0}],"module":"Certification","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-latex-module"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/Certification.lex.tex","sha256":"7e011c2fefdfd08c3f9d41a5cf5c891d72495aae7d4bc1e0b5d31a9d364c07fb"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Certification.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Certification.tex"}],"mappings":[{"artifact":0,"gen_end":366,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":0,"gen_end":450,"gen_start":366,"node":1,"role":"declaration","source":0,"src_end":407,"src_start":201},{"artifact":0,"gen_end":576,"gen_start":450,"node":2,"role":"declaration","source":0,"src_end":657,"src_start":409},{"artifact":0,"gen_end":636,"gen_start":576,"node":3,"role":"declaration","source":0,"src_end":792,"src_start":659},{"artifact":0,"gen_end":832,"gen_start":636,"node":4,"role":"declaration","source":0,"src_end":1116,"src_start":794},{"artifact":0,"gen_end":1074,"gen_start":832,"node":5,"role":"declaration","source":0,"src_end":1482,"src_start":1118},{"artifact":0,"gen_end":1235,"gen_start":1074,"node":6,"role":"declaration","source":0,"src_end":1799,"src_start":1484},{"artifact":0,"gen_end":1500,"gen_start":1235,"node":7,"role":"declaration","source":0,"src_end":2280,"src_start":1801},{"artifact":0,"gen_end":2160,"gen_start":1500,"node":8,"role":"declaration","source":0,"src_end":3365,"src_start":2282},{"artifact":0,"gen_end":2337,"gen_start":2160,"node":9,"role":"declaration","source":0,"src_end":3651,"src_start":3367},{"artifact":0,"gen_end":2478,"gen_start":2337,"node":10,"role":"declaration","source":0,"src_end":3885,"src_start":3653},{"artifact":0,"gen_end":2616,"gen_start":2478,"node":11,"role":"declaration","source":0,"src_end":4121,"src_start":3887},{"artifact":0,"gen_end":2989,"gen_start":2616,"node":12,"role":"declaration","source":0,"src_end":4517,"src_start":4123},{"artifact":0,"gen_end":3302,"gen_start":2989,"node":13,"role":"declaration","source":0,"src_end":4914,"src_start":4519},{"artifact":0,"gen_end":3619,"gen_start":3302,"node":14,"role":"declaration","source":0,"src_end":5325,"src_start":4916},{"artifact":0,"gen_end":3878,"gen_start":3619,"node":15,"role":"declaration","source":0,"src_end":5674,"src_start":5327},{"artifact":0,"gen_end":4133,"gen_start":3878,"node":16,"role":"declaration","source":0,"src_end":6017,"src_start":5676},{"artifact":0,"gen_end":4677,"gen_start":4133,"node":17,"role":"declaration","source":0,"src_end":6519,"src_start":6019},{"artifact":0,"gen_end":4884,"gen_start":4677,"node":18,"role":"declaration","source":0,"src_end":6783,"src_start":6521},{"artifact":0,"gen_end":5084,"gen_start":4884,"node":19,"role":"declaration","source":0,"src_end":7039,"src_start":6785},{"artifact":0,"gen_end":6370,"gen_start":5084,"node":20,"role":"declaration","source":0,"src_end":8308,"src_start":7041},{"artifact":0,"gen_end":7715,"gen_start":6370,"node":21,"role":"declaration","source":0,"src_end":9621,"src_start":8310},{"artifact":0,"gen_end":9057,"gen_start":7715,"node":22,"role":"declaration","source":0,"src_end":10932,"src_start":9623},{"artifact":0,"gen_end":9280,"gen_start":9057,"node":23,"role":"declaration","source":0,"src_end":11199,"src_start":10934},{"artifact":0,"gen_end":9510,"gen_start":9280,"node":24,"role":"declaration","source":0,"src_end":11473,"src_start":11201},{"artifact":0,"gen_end":9731,"gen_start":9510,"node":25,"role":"declaration","source":0,"src_end":11738,"src_start":11475},{"artifact":0,"gen_end":11171,"gen_start":9731,"node":26,"role":"declaration","source":0,"src_end":13152,"src_start":11740},{"artifact":0,"gen_end":11419,"gen_start":11171,"node":27,"role":"declaration","source":0,"src_end":13455,"src_start":13154},{"artifact":0,"gen_end":11642,"gen_start":11419,"node":28,"role":"declaration","source":0,"src_end":13733,"src_start":13457},{"artifact":0,"gen_end":11847,"gen_start":11642,"node":29,"role":"declaration","source":0,"src_end":13990,"src_start":13735},{"artifact":0,"gen_end":12046,"gen_start":11847,"node":30,"role":"declaration","source":0,"src_end":14270,"src_start":13992},{"artifact":0,"gen_end":12880,"gen_start":12046,"node":31,"role":"declaration","source":0,"src_end":15243,"src_start":14272},{"artifact":0,"gen_end":13469,"gen_start":12880,"node":32,"role":"declaration","source":0,"src_end":15856,"src_start":15245},{"artifact":0,"gen_end":13799,"gen_start":13469,"node":33,"role":"declaration","source":0,"src_end":16150,"src_start":15858},{"artifact":0,"gen_end":14284,"gen_start":13799,"node":34,"role":"declaration","source":0,"src_end":16581,"src_start":16152},{"artifact":0,"gen_end":14785,"gen_start":14284,"node":35,"role":"declaration","source":0,"src_end":17058,"src_start":16583},{"artifact":0,"gen_end":15152,"gen_start":14785,"node":36,"role":"declaration","source":0,"src_end":17427,"src_start":17060},{"artifact":0,"gen_end":17284,"gen_start":15152,"node":37,"role":"declaration","source":0,"src_end":19582,"src_start":17429},{"artifact":0,"gen_end":17926,"gen_start":17284,"node":38,"role":"declaration","source":0,"src_end":20233,"src_start":19584},{"artifact":0,"gen_end":18209,"gen_start":17926,"node":39,"role":"declaration","source":0,"src_end":20543,"src_start":20235},{"artifact":0,"gen_end":18829,"gen_start":18209,"node":40,"role":"declaration","source":0,"src_end":21235,"src_start":20545},{"artifact":0,"gen_end":19203,"gen_start":18829,"node":41,"role":"declaration","source":0,"src_end":21620,"src_start":21237},{"artifact":0,"gen_end":19619,"gen_start":19203,"node":42,"role":"declaration","source":0,"src_end":22028,"src_start":21622},{"artifact":0,"gen_end":20067,"gen_start":19619,"node":43,"role":"declaration","source":0,"src_end":22454,"src_start":22030},{"artifact":0,"gen_end":20548,"gen_start":20067,"node":44,"role":"declaration","source":0,"src_end":22889,"src_start":22456},{"artifact":0,"gen_end":21205,"gen_start":20548,"node":45,"role":"declaration","source":0,"src_end":23509,"src_start":22891},{"artifact":0,"gen_end":21862,"gen_start":21205,"node":46,"role":"declaration","source":0,"src_end":24129,"src_start":23511},{"artifact":0,"gen_end":22174,"gen_start":21862,"node":47,"role":"declaration","source":0,"src_end":24502,"src_start":24131},{"artifact":0,"gen_end":22484,"gen_start":22174,"node":48,"role":"declaration","source":0,"src_end":24873,"src_start":24504},{"artifact":0,"gen_end":22923,"gen_start":22484,"node":49,"role":"declaration","source":0,"src_end":25355,"src_start":24875},{"artifact":0,"gen_end":23733,"gen_start":22923,"node":50,"role":"declaration","source":0,"src_end":26212,"src_start":25357},{"artifact":0,"gen_end":24375,"gen_start":23733,"node":51,"role":"declaration","source":0,"src_end":26941,"src_start":26214},{"artifact":0,"gen_end":24887,"gen_start":24375,"node":52,"role":"declaration","source":0,"src_end":27477,"src_start":26943},{"artifact":0,"gen_end":26207,"gen_start":24887,"node":53,"role":"declaration","source":0,"src_end":29190,"src_start":27479},{"artifact":0,"gen_end":26746,"gen_start":26207,"node":54,"role":"declaration","source":0,"src_end":29753,"src_start":29192},{"artifact":0,"gen_end":27355,"gen_start":26746,"node":55,"role":"declaration","source":0,"src_end":30529,"src_start":29755},{"artifact":0,"gen_end":28115,"gen_start":27355,"node":56,"role":"declaration","source":0,"src_end":31375,"src_start":30531},{"artifact":0,"gen_end":29541,"gen_start":28115,"node":57,"role":"declaration","source":0,"src_end":33169,"src_start":31377},{"artifact":0,"gen_end":30079,"gen_start":29541,"node":58,"role":"declaration","source":0,"src_end":33739,"src_start":33171},{"artifact":0,"gen_end":30806,"gen_start":30079,"node":59,"role":"declaration","source":0,"src_end":34548,"src_start":33741},{"artifact":0,"gen_end":31453,"gen_start":30806,"node":60,"role":"declaration","source":0,"src_end":35508,"src_start":34550},{"artifact":0,"gen_end":32255,"gen_start":31453,"node":61,"role":"declaration","source":0,"src_end":36352,"src_start":35510},{"artifact":0,"gen_end":33068,"gen_start":32255,"node":62,"role":"declaration","source":0,"src_end":37402,"src_start":36354},{"artifact":0,"gen_end":33378,"gen_start":33068,"node":63,"role":"declaration","source":0,"src_end":37757,"src_start":37404},{"artifact":0,"gen_end":33951,"gen_start":33378,"node":64,"role":"declaration","source":0,"src_end":38410,"src_start":37759},{"artifact":0,"gen_end":35798,"gen_start":33951,"node":65,"role":"declaration","source":0,"src_end":40615,"src_start":38412},{"artifact":0,"gen_end":37108,"gen_start":35798,"node":66,"role":"declaration","source":0,"src_end":42146,"src_start":40617},{"artifact":0,"gen_end":38939,"gen_start":37108,"node":67,"role":"declaration","source":0,"src_end":43756,"src_start":42148},{"artifact":0,"gen_end":39386,"gen_start":38939,"node":68,"role":"declaration","source":0,"src_end":44146,"src_start":43758},{"artifact":0,"gen_end":40167,"gen_start":39386,"node":69,"role":"declaration","source":0,"src_end":44821,"src_start":44148},{"artifact":0,"gen_end":43058,"gen_start":40167,"node":70,"role":"declaration","source":0,"src_end":47859,"src_start":44823},{"artifact":0,"gen_end":43091,"gen_start":43058,"node":0,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":71,"role":"declaration","source":0,"src_end":47895,"src_start":0},{"artifact":1,"gen_end":392,"gen_start":134,"node":72,"role":"declaration","source":0,"src_end":407,"src_start":201},{"artifact":1,"gen_end":716,"gen_start":392,"node":73,"role":"declaration","source":0,"src_end":657,"src_start":409},{"artifact":1,"gen_end":887,"gen_start":716,"node":74,"role":"declaration","source":0,"src_end":792,"src_start":659},{"artifact":1,"gen_end":1309,"gen_start":887,"node":75,"role":"declaration","source":0,"src_end":1116,"src_start":794},{"artifact":1,"gen_end":1838,"gen_start":1309,"node":76,"role":"declaration","source":0,"src_end":1482,"src_start":1118},{"artifact":1,"gen_end":2277,"gen_start":1838,"node":77,"role":"declaration","source":0,"src_end":1799,"src_start":1484},{"artifact":1,"gen_end":2965,"gen_start":2277,"node":78,"role":"declaration","source":0,"src_end":2280,"src_start":1801},{"artifact":1,"gen_end":4556,"gen_start":2965,"node":79,"role":"declaration","source":0,"src_end":3365,"src_start":2282},{"artifact":1,"gen_end":4916,"gen_start":4556,"node":80,"role":"declaration","source":0,"src_end":3651,"src_start":3367},{"artifact":1,"gen_end":5200,"gen_start":4916,"node":81,"role":"declaration","source":0,"src_end":3885,"src_start":3653},{"artifact":1,"gen_end":5486,"gen_start":5200,"node":82,"role":"declaration","source":0,"src_end":4121,"src_start":3887},{"artifact":1,"gen_end":6020,"gen_start":5486,"node":83,"role":"declaration","source":0,"src_end":4517,"src_start":4123},{"artifact":1,"gen_end":6512,"gen_start":6020,"node":84,"role":"declaration","source":0,"src_end":4914,"src_start":4519},{"artifact":1,"gen_end":7008,"gen_start":6512,"node":85,"role":"declaration","source":0,"src_end":5325,"src_start":4916},{"artifact":1,"gen_end":7446,"gen_start":7008,"node":86,"role":"declaration","source":0,"src_end":5674,"src_start":5327},{"artifact":1,"gen_end":7880,"gen_start":7446,"node":87,"role":"declaration","source":0,"src_end":6017,"src_start":5676},{"artifact":1,"gen_end":8578,"gen_start":7880,"node":88,"role":"declaration","source":0,"src_end":6519,"src_start":6019},{"artifact":1,"gen_end":8970,"gen_start":8578,"node":89,"role":"declaration","source":0,"src_end":6783,"src_start":6521},{"artifact":1,"gen_end":9355,"gen_start":8970,"node":90,"role":"declaration","source":0,"src_end":7039,"src_start":6785},{"artifact":1,"gen_end":10846,"gen_start":9355,"node":91,"role":"declaration","source":0,"src_end":8308,"src_start":7041},{"artifact":1,"gen_end":12396,"gen_start":10846,"node":92,"role":"declaration","source":0,"src_end":9621,"src_start":8310},{"artifact":1,"gen_end":13943,"gen_start":12396,"node":93,"role":"declaration","source":0,"src_end":10932,"src_start":9623},{"artifact":1,"gen_end":14348,"gen_start":13943,"node":94,"role":"declaration","source":0,"src_end":11199,"src_start":10934},{"artifact":1,"gen_end":14760,"gen_start":14348,"node":95,"role":"declaration","source":0,"src_end":11473,"src_start":11201},{"artifact":1,"gen_end":15163,"gen_start":14760,"node":96,"role":"declaration","source":0,"src_end":11738,"src_start":11475},{"artifact":1,"gen_end":16894,"gen_start":15163,"node":97,"role":"declaration","source":0,"src_end":13152,"src_start":11740},{"artifact":1,"gen_end":17397,"gen_start":16894,"node":98,"role":"declaration","source":0,"src_end":13455,"src_start":13154},{"artifact":1,"gen_end":17875,"gen_start":17397,"node":99,"role":"declaration","source":0,"src_end":13733,"src_start":13457},{"artifact":1,"gen_end":18335,"gen_start":17875,"node":100,"role":"declaration","source":0,"src_end":13990,"src_start":13735},{"artifact":1,"gen_end":18733,"gen_start":18335,"node":101,"role":"declaration","source":0,"src_end":14270,"src_start":13992},{"artifact":1,"gen_end":19757,"gen_start":18733,"node":102,"role":"declaration","source":0,"src_end":15243,"src_start":14272},{"artifact":1,"gen_end":20533,"gen_start":19757,"node":103,"role":"declaration","source":0,"src_end":15856,"src_start":15245},{"artifact":1,"gen_end":21045,"gen_start":20533,"node":104,"role":"declaration","source":0,"src_end":16150,"src_start":15858},{"artifact":1,"gen_end":21712,"gen_start":21045,"node":105,"role":"declaration","source":0,"src_end":16581,"src_start":16152},{"artifact":1,"gen_end":22399,"gen_start":21712,"node":106,"role":"declaration","source":0,"src_end":17058,"src_start":16583},{"artifact":1,"gen_end":22952,"gen_start":22399,"node":107,"role":"declaration","source":0,"src_end":17427,"src_start":17060},{"artifact":1,"gen_end":25312,"gen_start":22952,"node":108,"role":"declaration","source":0,"src_end":19582,"src_start":17429},{"artifact":1,"gen_end":26114,"gen_start":25312,"node":109,"role":"declaration","source":0,"src_end":20233,"src_start":19584},{"artifact":1,"gen_end":26576,"gen_start":26114,"node":110,"role":"declaration","source":0,"src_end":20543,"src_start":20235},{"artifact":1,"gen_end":27372,"gen_start":26576,"node":111,"role":"declaration","source":0,"src_end":21235,"src_start":20545},{"artifact":1,"gen_end":27920,"gen_start":27372,"node":112,"role":"declaration","source":0,"src_end":21620,"src_start":21237},{"artifact":1,"gen_end":28559,"gen_start":27920,"node":113,"role":"declaration","source":0,"src_end":22028,"src_start":21622},{"artifact":1,"gen_end":29193,"gen_start":28559,"node":114,"role":"declaration","source":0,"src_end":22454,"src_start":22030},{"artifact":1,"gen_end":29858,"gen_start":29193,"node":115,"role":"declaration","source":0,"src_end":22889,"src_start":22456},{"artifact":1,"gen_end":30655,"gen_start":29858,"node":116,"role":"declaration","source":0,"src_end":23509,"src_start":22891},{"artifact":1,"gen_end":31452,"gen_start":30655,"node":117,"role":"declaration","source":0,"src_end":24129,"src_start":23511},{"artifact":1,"gen_end":31987,"gen_start":31452,"node":118,"role":"declaration","source":0,"src_end":24502,"src_start":24131},{"artifact":1,"gen_end":32520,"gen_start":31987,"node":119,"role":"declaration","source":0,"src_end":24873,"src_start":24504},{"artifact":1,"gen_end":33186,"gen_start":32520,"node":120,"role":"declaration","source":0,"src_end":25355,"src_start":24875},{"artifact":1,"gen_end":34220,"gen_start":33186,"node":121,"role":"declaration","source":0,"src_end":26212,"src_start":25357},{"artifact":1,"gen_end":35040,"gen_start":34220,"node":122,"role":"declaration","source":0,"src_end":26941,"src_start":26214},{"artifact":1,"gen_end":35776,"gen_start":35040,"node":123,"role":"declaration","source":0,"src_end":27477,"src_start":26943},{"artifact":1,"gen_end":37283,"gen_start":35776,"node":124,"role":"declaration","source":0,"src_end":29190,"src_start":27479},{"artifact":1,"gen_end":37931,"gen_start":37283,"node":125,"role":"declaration","source":0,"src_end":29753,"src_start":29192},{"artifact":1,"gen_end":38726,"gen_start":37931,"node":126,"role":"declaration","source":0,"src_end":30529,"src_start":29755},{"artifact":1,"gen_end":39672,"gen_start":38726,"node":127,"role":"declaration","source":0,"src_end":31375,"src_start":30531},{"artifact":1,"gen_end":41284,"gen_start":39672,"node":128,"role":"declaration","source":0,"src_end":33169,"src_start":31377},{"artifact":1,"gen_end":41945,"gen_start":41284,"node":129,"role":"declaration","source":0,"src_end":33739,"src_start":33171},{"artifact":1,"gen_end":42858,"gen_start":41945,"node":130,"role":"declaration","source":0,"src_end":34548,"src_start":33741},{"artifact":1,"gen_end":43683,"gen_start":42858,"node":131,"role":"declaration","source":0,"src_end":35508,"src_start":34550},{"artifact":1,"gen_end":44669,"gen_start":43683,"node":132,"role":"declaration","source":0,"src_end":36352,"src_start":35510},{"artifact":1,"gen_end":45667,"gen_start":44669,"node":133,"role":"declaration","source":0,"src_end":37402,"src_start":36354},{"artifact":1,"gen_end":46132,"gen_start":45667,"node":134,"role":"declaration","source":0,"src_end":37757,"src_start":37404},{"artifact":1,"gen_end":46840,"gen_start":46132,"node":135,"role":"declaration","source":0,"src_end":38410,"src_start":37759},{"artifact":1,"gen_end":48872,"gen_start":46840,"node":136,"role":"declaration","source":0,"src_end":40615,"src_start":38412},{"artifact":1,"gen_end":50367,"gen_start":48872,"node":137,"role":"declaration","source":0,"src_end":42146,"src_start":40617},{"artifact":1,"gen_end":52385,"gen_start":50367,"node":138,"role":"declaration","source":0,"src_end":43756,"src_start":42148},{"artifact":1,"gen_end":53014,"gen_start":52385,"node":139,"role":"declaration","source":0,"src_end":44146,"src_start":43758},{"artifact":1,"gen_end":53977,"gen_start":53014,"node":140,"role":"declaration","source":0,"src_end":44821,"src_start":44148},{"artifact":1,"gen_end":57118,"gen_start":53977,"node":141,"role":"declaration","source":0,"src_end":47859,"src_start":44823},{"artifact":1,"gen_end":57133,"gen_start":57118,"node":71,"role":"declaration","source":0,"src_end":47895,"src_start":0}],"module":"Certification","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-latex-module"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/Certification.lex.tex","sha256":"7e011c2fefdfd08c3f9d41a5cf5c891d72495aae7d4bc1e0b5d31a9d364c07fb"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/Gnaf.map.json b/compiler/expected/build/maps/LexLeanTarget/Gnaf.map.json index 51c9b7c65..a2e272620 100644 --- a/compiler/expected/build/maps/LexLeanTarget/Gnaf.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/Gnaf.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Gnaf.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Gnaf.tex"}],"mappings":[{"artifact":0,"gen_end":324,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":0,"gen_end":1115,"gen_start":324,"node":1,"role":"declaration","source":0,"src_end":1644,"src_start":172},{"artifact":0,"gen_end":1301,"gen_start":1115,"node":2,"role":"declaration","source":0,"src_end":2101,"src_start":1646},{"artifact":0,"gen_end":1389,"gen_start":1301,"node":3,"role":"declaration","source":0,"src_end":2327,"src_start":2103},{"artifact":0,"gen_end":1458,"gen_start":1389,"node":4,"role":"declaration","source":0,"src_end":2471,"src_start":2329},{"artifact":0,"gen_end":1539,"gen_start":1458,"node":5,"role":"declaration","source":0,"src_end":2676,"src_start":2473},{"artifact":0,"gen_end":1597,"gen_start":1539,"node":6,"role":"declaration","source":0,"src_end":2825,"src_start":2678},{"artifact":0,"gen_end":1689,"gen_start":1597,"node":7,"role":"declaration","source":0,"src_end":3036,"src_start":2827},{"artifact":0,"gen_end":1762,"gen_start":1689,"node":8,"role":"declaration","source":0,"src_end":3184,"src_start":3038},{"artifact":0,"gen_end":1934,"gen_start":1762,"node":9,"role":"declaration","source":0,"src_end":3507,"src_start":3186},{"artifact":0,"gen_end":2030,"gen_start":1934,"node":10,"role":"declaration","source":0,"src_end":3670,"src_start":3509},{"artifact":0,"gen_end":2139,"gen_start":2030,"node":11,"role":"declaration","source":0,"src_end":3853,"src_start":3672},{"artifact":0,"gen_end":2303,"gen_start":2139,"node":12,"role":"declaration","source":0,"src_end":4110,"src_start":3855},{"artifact":0,"gen_end":2442,"gen_start":2303,"node":13,"role":"declaration","source":0,"src_end":4401,"src_start":4112},{"artifact":0,"gen_end":2550,"gen_start":2442,"node":14,"role":"declaration","source":0,"src_end":4654,"src_start":4403},{"artifact":0,"gen_end":2638,"gen_start":2550,"node":15,"role":"declaration","source":0,"src_end":4866,"src_start":4656},{"artifact":0,"gen_end":2694,"gen_start":2638,"node":16,"role":"declaration","source":0,"src_end":5013,"src_start":4868},{"artifact":0,"gen_end":2981,"gen_start":2694,"node":17,"role":"declaration","source":0,"src_end":5469,"src_start":5015},{"artifact":0,"gen_end":3597,"gen_start":2981,"node":18,"role":"declaration","source":0,"src_end":6545,"src_start":5471},{"artifact":0,"gen_end":3693,"gen_start":3597,"node":19,"role":"declaration","source":0,"src_end":6753,"src_start":6547},{"artifact":0,"gen_end":3851,"gen_start":3693,"node":20,"role":"declaration","source":0,"src_end":7051,"src_start":6755},{"artifact":0,"gen_end":4221,"gen_start":3851,"node":21,"role":"declaration","source":0,"src_end":7487,"src_start":7053},{"artifact":0,"gen_end":4352,"gen_start":4221,"node":22,"role":"declaration","source":0,"src_end":7639,"src_start":7489},{"artifact":0,"gen_end":4759,"gen_start":4352,"node":23,"role":"declaration","source":0,"src_end":8112,"src_start":7641},{"artifact":0,"gen_end":5169,"gen_start":4759,"node":24,"role":"declaration","source":0,"src_end":8588,"src_start":8114},{"artifact":0,"gen_end":5454,"gen_start":5169,"node":25,"role":"declaration","source":0,"src_end":8976,"src_start":8590},{"artifact":0,"gen_end":5693,"gen_start":5454,"node":26,"role":"declaration","source":0,"src_end":9280,"src_start":8978},{"artifact":0,"gen_end":6018,"gen_start":5693,"node":27,"role":"declaration","source":0,"src_end":9716,"src_start":9282},{"artifact":0,"gen_end":6511,"gen_start":6018,"node":28,"role":"declaration","source":0,"src_end":10381,"src_start":9718},{"artifact":0,"gen_end":6738,"gen_start":6511,"node":29,"role":"declaration","source":0,"src_end":10679,"src_start":10383},{"artifact":0,"gen_end":7691,"gen_start":6738,"node":30,"role":"declaration","source":0,"src_end":11943,"src_start":10681},{"artifact":0,"gen_end":8027,"gen_start":7691,"node":31,"role":"declaration","source":0,"src_end":12377,"src_start":11945},{"artifact":0,"gen_end":8708,"gen_start":8027,"node":32,"role":"declaration","source":0,"src_end":13311,"src_start":12379},{"artifact":0,"gen_end":8999,"gen_start":8708,"node":33,"role":"declaration","source":0,"src_end":13652,"src_start":13313},{"artifact":0,"gen_end":9222,"gen_start":8999,"node":34,"role":"declaration","source":0,"src_end":13926,"src_start":13654},{"artifact":0,"gen_end":9582,"gen_start":9222,"node":35,"role":"declaration","source":0,"src_end":14392,"src_start":13928},{"artifact":0,"gen_end":9941,"gen_start":9582,"node":36,"role":"declaration","source":0,"src_end":14853,"src_start":14394},{"artifact":0,"gen_end":10288,"gen_start":9941,"node":37,"role":"declaration","source":0,"src_end":15279,"src_start":14855},{"artifact":0,"gen_end":10498,"gen_start":10288,"node":38,"role":"declaration","source":0,"src_end":15568,"src_start":15281},{"artifact":0,"gen_end":10687,"gen_start":10498,"node":39,"role":"declaration","source":0,"src_end":15819,"src_start":15570},{"artifact":0,"gen_end":10873,"gen_start":10687,"node":40,"role":"declaration","source":0,"src_end":16055,"src_start":15821},{"artifact":0,"gen_end":11364,"gen_start":10873,"node":41,"role":"declaration","source":0,"src_end":16604,"src_start":16057},{"artifact":0,"gen_end":11595,"gen_start":11364,"node":42,"role":"declaration","source":0,"src_end":16892,"src_start":16606},{"artifact":0,"gen_end":11779,"gen_start":11595,"node":43,"role":"declaration","source":0,"src_end":17153,"src_start":16894},{"artifact":0,"gen_end":12091,"gen_start":11779,"node":44,"role":"declaration","source":0,"src_end":17490,"src_start":17155},{"artifact":0,"gen_end":12434,"gen_start":12091,"node":45,"role":"declaration","source":0,"src_end":17847,"src_start":17492},{"artifact":0,"gen_end":12734,"gen_start":12434,"node":46,"role":"declaration","source":0,"src_end":18200,"src_start":17849},{"artifact":0,"gen_end":12976,"gen_start":12734,"node":47,"role":"declaration","source":0,"src_end":18473,"src_start":18202},{"artifact":0,"gen_end":13351,"gen_start":12976,"node":48,"role":"declaration","source":0,"src_end":18856,"src_start":18475},{"artifact":0,"gen_end":13497,"gen_start":13351,"node":49,"role":"declaration","source":0,"src_end":19040,"src_start":18858},{"artifact":0,"gen_end":13578,"gen_start":13497,"node":50,"role":"declaration","source":0,"src_end":19159,"src_start":19042},{"artifact":0,"gen_end":13659,"gen_start":13578,"node":51,"role":"declaration","source":0,"src_end":19278,"src_start":19161},{"artifact":0,"gen_end":13745,"gen_start":13659,"node":52,"role":"declaration","source":0,"src_end":19402,"src_start":19280},{"artifact":0,"gen_end":13831,"gen_start":13745,"node":53,"role":"declaration","source":0,"src_end":19526,"src_start":19404},{"artifact":0,"gen_end":13980,"gen_start":13831,"node":54,"role":"declaration","source":0,"src_end":19713,"src_start":19528},{"artifact":0,"gen_end":14130,"gen_start":13980,"node":55,"role":"declaration","source":0,"src_end":19901,"src_start":19715},{"artifact":0,"gen_end":14261,"gen_start":14130,"node":56,"role":"declaration","source":0,"src_end":20056,"src_start":19903},{"artifact":0,"gen_end":14392,"gen_start":14261,"node":57,"role":"declaration","source":0,"src_end":20211,"src_start":20058},{"artifact":0,"gen_end":14817,"gen_start":14392,"node":58,"role":"declaration","source":0,"src_end":21190,"src_start":20213},{"artifact":0,"gen_end":15138,"gen_start":14817,"node":59,"role":"declaration","source":0,"src_end":21712,"src_start":21192},{"artifact":0,"gen_end":15520,"gen_start":15138,"node":60,"role":"declaration","source":0,"src_end":22295,"src_start":21714},{"artifact":0,"gen_end":15786,"gen_start":15520,"node":61,"role":"declaration","source":0,"src_end":22759,"src_start":22297},{"artifact":0,"gen_end":16081,"gen_start":15786,"node":62,"role":"declaration","source":0,"src_end":23265,"src_start":22761},{"artifact":0,"gen_end":16423,"gen_start":16081,"node":63,"role":"declaration","source":0,"src_end":23814,"src_start":23267},{"artifact":0,"gen_end":16759,"gen_start":16423,"node":64,"role":"declaration","source":0,"src_end":24357,"src_start":23816},{"artifact":0,"gen_end":17115,"gen_start":16759,"node":65,"role":"declaration","source":0,"src_end":24940,"src_start":24359},{"artifact":0,"gen_end":17471,"gen_start":17115,"node":66,"role":"declaration","source":0,"src_end":25526,"src_start":24942},{"artifact":0,"gen_end":18010,"gen_start":17471,"node":67,"role":"declaration","source":0,"src_end":26329,"src_start":25528},{"artifact":0,"gen_end":18592,"gen_start":18010,"node":68,"role":"declaration","source":0,"src_end":27278,"src_start":26331},{"artifact":0,"gen_end":19102,"gen_start":18592,"node":69,"role":"declaration","source":0,"src_end":28114,"src_start":27280},{"artifact":0,"gen_end":19556,"gen_start":19102,"node":70,"role":"declaration","source":0,"src_end":29040,"src_start":28116},{"artifact":0,"gen_end":22402,"gen_start":19556,"node":71,"role":"declaration","source":0,"src_end":32959,"src_start":29042},{"artifact":0,"gen_end":26270,"gen_start":22402,"node":72,"role":"declaration","source":0,"src_end":38890,"src_start":32961},{"artifact":0,"gen_end":27358,"gen_start":26270,"node":73,"role":"declaration","source":0,"src_end":39776,"src_start":38892},{"artifact":0,"gen_end":27599,"gen_start":27358,"node":74,"role":"declaration","source":0,"src_end":40071,"src_start":39778},{"artifact":0,"gen_end":28077,"gen_start":27599,"node":75,"role":"declaration","source":0,"src_end":40526,"src_start":40073},{"artifact":0,"gen_end":58298,"gen_start":28077,"node":76,"role":"declaration","source":0,"src_end":70968,"src_start":40528},{"artifact":0,"gen_end":58756,"gen_start":58298,"node":77,"role":"declaration","source":0,"src_end":71454,"src_start":70970},{"artifact":0,"gen_end":60041,"gen_start":58756,"node":78,"role":"declaration","source":0,"src_end":72731,"src_start":71456},{"artifact":0,"gen_end":60272,"gen_start":60041,"node":79,"role":"declaration","source":0,"src_end":73012,"src_start":72733},{"artifact":0,"gen_end":60478,"gen_start":60272,"node":80,"role":"declaration","source":0,"src_end":73260,"src_start":73014},{"artifact":0,"gen_end":60670,"gen_start":60478,"node":81,"role":"declaration","source":0,"src_end":73497,"src_start":73262},{"artifact":0,"gen_end":62519,"gen_start":60670,"node":82,"role":"declaration","source":0,"src_end":75195,"src_start":73499},{"artifact":0,"gen_end":62798,"gen_start":62519,"node":83,"role":"declaration","source":0,"src_end":75517,"src_start":75197},{"artifact":0,"gen_end":63052,"gen_start":62798,"node":84,"role":"declaration","source":0,"src_end":75814,"src_start":75519},{"artifact":0,"gen_end":63289,"gen_start":63052,"node":85,"role":"declaration","source":0,"src_end":76093,"src_start":75816},{"artifact":0,"gen_end":63618,"gen_start":63289,"node":86,"role":"declaration","source":0,"src_end":76522,"src_start":76095},{"artifact":0,"gen_end":63877,"gen_start":63618,"node":87,"role":"declaration","source":0,"src_end":76871,"src_start":76524},{"artifact":0,"gen_end":64275,"gen_start":63877,"node":88,"role":"declaration","source":0,"src_end":77300,"src_start":76873},{"artifact":0,"gen_end":64559,"gen_start":64275,"node":89,"role":"declaration","source":0,"src_end":77630,"src_start":77302},{"artifact":0,"gen_end":64874,"gen_start":64559,"node":90,"role":"declaration","source":0,"src_end":77959,"src_start":77632},{"artifact":0,"gen_end":65072,"gen_start":64874,"node":91,"role":"declaration","source":0,"src_end":78153,"src_start":77961},{"artifact":0,"gen_end":65422,"gen_start":65072,"node":92,"role":"declaration","source":0,"src_end":78556,"src_start":78155},{"artifact":0,"gen_end":65850,"gen_start":65422,"node":93,"role":"declaration","source":0,"src_end":79042,"src_start":78558},{"artifact":0,"gen_end":66213,"gen_start":65850,"node":94,"role":"declaration","source":0,"src_end":79475,"src_start":79044},{"artifact":0,"gen_end":66358,"gen_start":66213,"node":95,"role":"declaration","source":0,"src_end":79649,"src_start":79477},{"artifact":0,"gen_end":66602,"gen_start":66358,"node":96,"role":"declaration","source":0,"src_end":79961,"src_start":79651},{"artifact":0,"gen_end":66953,"gen_start":66602,"node":97,"role":"declaration","source":0,"src_end":80386,"src_start":79963},{"artifact":0,"gen_end":67084,"gen_start":66953,"node":98,"role":"declaration","source":0,"src_end":80555,"src_start":80388},{"artifact":0,"gen_end":67333,"gen_start":67084,"node":99,"role":"declaration","source":0,"src_end":80871,"src_start":80557},{"artifact":0,"gen_end":67633,"gen_start":67333,"node":100,"role":"declaration","source":0,"src_end":81229,"src_start":80873},{"artifact":0,"gen_end":67922,"gen_start":67633,"node":101,"role":"declaration","source":0,"src_end":81620,"src_start":81231},{"artifact":0,"gen_end":68177,"gen_start":67922,"node":102,"role":"declaration","source":0,"src_end":81928,"src_start":81622},{"artifact":0,"gen_end":68459,"gen_start":68177,"node":103,"role":"declaration","source":0,"src_end":82254,"src_start":81930},{"artifact":0,"gen_end":68657,"gen_start":68459,"node":104,"role":"declaration","source":0,"src_end":82485,"src_start":82256},{"artifact":0,"gen_end":68976,"gen_start":68657,"node":105,"role":"declaration","source":0,"src_end":82856,"src_start":82487},{"artifact":0,"gen_end":69190,"gen_start":68976,"node":106,"role":"declaration","source":0,"src_end":83100,"src_start":82858},{"artifact":0,"gen_end":69331,"gen_start":69190,"node":107,"role":"declaration","source":0,"src_end":83267,"src_start":83102},{"artifact":0,"gen_end":69566,"gen_start":69331,"node":108,"role":"declaration","source":0,"src_end":83570,"src_start":83269},{"artifact":0,"gen_end":69947,"gen_start":69566,"node":109,"role":"declaration","source":0,"src_end":83990,"src_start":83572},{"artifact":0,"gen_end":70207,"gen_start":69947,"node":110,"role":"declaration","source":0,"src_end":84313,"src_start":83992},{"artifact":0,"gen_end":70426,"gen_start":70207,"node":111,"role":"declaration","source":0,"src_end":84579,"src_start":84315},{"artifact":0,"gen_end":70518,"gen_start":70426,"node":112,"role":"declaration","source":0,"src_end":84692,"src_start":84581},{"artifact":0,"gen_end":71953,"gen_start":70518,"node":113,"role":"declaration","source":0,"src_end":86153,"src_start":84694},{"artifact":0,"gen_end":72649,"gen_start":71953,"node":114,"role":"declaration","source":0,"src_end":86989,"src_start":86155},{"artifact":0,"gen_end":73040,"gen_start":72649,"node":115,"role":"declaration","source":0,"src_end":87424,"src_start":86991},{"artifact":0,"gen_end":73320,"gen_start":73040,"node":116,"role":"declaration","source":0,"src_end":87815,"src_start":87426},{"artifact":0,"gen_end":73738,"gen_start":73320,"node":117,"role":"declaration","source":0,"src_end":88306,"src_start":87817},{"artifact":0,"gen_end":74019,"gen_start":73738,"node":118,"role":"declaration","source":0,"src_end":88661,"src_start":88308},{"artifact":0,"gen_end":74661,"gen_start":74019,"node":119,"role":"declaration","source":0,"src_end":89445,"src_start":88663},{"artifact":0,"gen_end":75089,"gen_start":74661,"node":120,"role":"declaration","source":0,"src_end":90031,"src_start":89447},{"artifact":0,"gen_end":75854,"gen_start":75089,"node":121,"role":"declaration","source":0,"src_end":90987,"src_start":90033},{"artifact":0,"gen_end":76281,"gen_start":75854,"node":122,"role":"declaration","source":0,"src_end":91513,"src_start":90989},{"artifact":0,"gen_end":76626,"gen_start":76281,"node":123,"role":"declaration","source":0,"src_end":91889,"src_start":91515},{"artifact":0,"gen_end":77071,"gen_start":76626,"node":124,"role":"declaration","source":0,"src_end":92375,"src_start":91891},{"artifact":0,"gen_end":77645,"gen_start":77071,"node":125,"role":"declaration","source":0,"src_end":92995,"src_start":92377},{"artifact":0,"gen_end":78103,"gen_start":77645,"node":126,"role":"declaration","source":0,"src_end":93423,"src_start":92997},{"artifact":0,"gen_end":78477,"gen_start":78103,"node":127,"role":"declaration","source":0,"src_end":93830,"src_start":93425},{"artifact":0,"gen_end":79004,"gen_start":78477,"node":128,"role":"declaration","source":0,"src_end":94310,"src_start":93832},{"artifact":0,"gen_end":79268,"gen_start":79004,"node":129,"role":"declaration","source":0,"src_end":94650,"src_start":94312},{"artifact":0,"gen_end":79572,"gen_start":79268,"node":130,"role":"declaration","source":0,"src_end":94989,"src_start":94652},{"artifact":0,"gen_end":79695,"gen_start":79572,"node":131,"role":"declaration","source":0,"src_end":95133,"src_start":94991},{"artifact":0,"gen_end":79886,"gen_start":79695,"node":132,"role":"declaration","source":0,"src_end":95333,"src_start":95135},{"artifact":0,"gen_end":80096,"gen_start":79886,"node":133,"role":"declaration","source":0,"src_end":95561,"src_start":95335},{"artifact":0,"gen_end":80242,"gen_start":80096,"node":134,"role":"declaration","source":0,"src_end":95723,"src_start":95563},{"artifact":0,"gen_end":80404,"gen_start":80242,"node":135,"role":"declaration","source":0,"src_end":95896,"src_start":95725},{"artifact":0,"gen_end":80796,"gen_start":80404,"node":136,"role":"declaration","source":0,"src_end":96300,"src_start":95898},{"artifact":0,"gen_end":81205,"gen_start":80796,"node":137,"role":"declaration","source":0,"src_end":96721,"src_start":96302},{"artifact":0,"gen_end":81620,"gen_start":81205,"node":138,"role":"declaration","source":0,"src_end":97113,"src_start":96723},{"artifact":0,"gen_end":82064,"gen_start":81620,"node":139,"role":"declaration","source":0,"src_end":97536,"src_start":97115},{"artifact":0,"gen_end":82376,"gen_start":82064,"node":140,"role":"declaration","source":0,"src_end":97869,"src_start":97538},{"artifact":0,"gen_end":82718,"gen_start":82376,"node":141,"role":"declaration","source":0,"src_end":98230,"src_start":97871},{"artifact":0,"gen_end":83046,"gen_start":82718,"node":142,"role":"declaration","source":0,"src_end":98577,"src_start":98232},{"artifact":0,"gen_end":83571,"gen_start":83046,"node":143,"role":"declaration","source":0,"src_end":99100,"src_start":98579},{"artifact":0,"gen_end":83692,"gen_start":83571,"node":144,"role":"declaration","source":0,"src_end":99250,"src_start":99102},{"artifact":0,"gen_end":83876,"gen_start":83692,"node":145,"role":"declaration","source":0,"src_end":99491,"src_start":99252},{"artifact":0,"gen_end":84139,"gen_start":83876,"node":146,"role":"declaration","source":0,"src_end":99766,"src_start":99493},{"artifact":0,"gen_end":84272,"gen_start":84139,"node":147,"role":"declaration","source":0,"src_end":99965,"src_start":99768},{"artifact":0,"gen_end":84404,"gen_start":84272,"node":148,"role":"declaration","source":0,"src_end":100163,"src_start":99967},{"artifact":0,"gen_end":84539,"gen_start":84404,"node":149,"role":"declaration","source":0,"src_end":100368,"src_start":100165},{"artifact":0,"gen_end":84622,"gen_start":84539,"node":150,"role":"declaration","source":0,"src_end":100497,"src_start":100370},{"artifact":0,"gen_end":84704,"gen_start":84622,"node":151,"role":"declaration","source":0,"src_end":100625,"src_start":100499},{"artifact":0,"gen_end":84850,"gen_start":84704,"node":152,"role":"declaration","source":0,"src_end":100811,"src_start":100627},{"artifact":0,"gen_end":84874,"gen_start":84850,"node":0,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":153,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":1,"gen_end":2330,"gen_start":134,"node":154,"role":"declaration","source":0,"src_end":1644,"src_start":172},{"artifact":1,"gen_end":3005,"gen_start":2330,"node":155,"role":"declaration","source":0,"src_end":2101,"src_start":1646},{"artifact":1,"gen_end":3305,"gen_start":3005,"node":156,"role":"declaration","source":0,"src_end":2327,"src_start":2103},{"artifact":1,"gen_end":3485,"gen_start":3305,"node":157,"role":"declaration","source":0,"src_end":2471,"src_start":2329},{"artifact":1,"gen_end":3740,"gen_start":3485,"node":158,"role":"declaration","source":0,"src_end":2676,"src_start":2473},{"artifact":1,"gen_end":3927,"gen_start":3740,"node":159,"role":"declaration","source":0,"src_end":2825,"src_start":2678},{"artifact":1,"gen_end":4202,"gen_start":3927,"node":160,"role":"declaration","source":0,"src_end":3036,"src_start":2827},{"artifact":1,"gen_end":4386,"gen_start":4202,"node":161,"role":"declaration","source":0,"src_end":3184,"src_start":3038},{"artifact":1,"gen_end":4813,"gen_start":4386,"node":162,"role":"declaration","source":0,"src_end":3507,"src_start":3186},{"artifact":1,"gen_end":5014,"gen_start":4813,"node":163,"role":"declaration","source":0,"src_end":3670,"src_start":3509},{"artifact":1,"gen_end":5234,"gen_start":5014,"node":164,"role":"declaration","source":0,"src_end":3853,"src_start":3672},{"artifact":1,"gen_end":5581,"gen_start":5234,"node":165,"role":"declaration","source":0,"src_end":4110,"src_start":3855},{"artifact":1,"gen_end":5970,"gen_start":5581,"node":166,"role":"declaration","source":0,"src_end":4401,"src_start":4112},{"artifact":1,"gen_end":6297,"gen_start":5970,"node":167,"role":"declaration","source":0,"src_end":4654,"src_start":4403},{"artifact":1,"gen_end":6559,"gen_start":6297,"node":168,"role":"declaration","source":0,"src_end":4866,"src_start":4656},{"artifact":1,"gen_end":6744,"gen_start":6559,"node":169,"role":"declaration","source":0,"src_end":5013,"src_start":4868},{"artifact":1,"gen_end":7390,"gen_start":6744,"node":170,"role":"declaration","source":0,"src_end":5469,"src_start":5015},{"artifact":1,"gen_end":8948,"gen_start":7390,"node":171,"role":"declaration","source":0,"src_end":6545,"src_start":5471},{"artifact":1,"gen_end":9206,"gen_start":8948,"node":172,"role":"declaration","source":0,"src_end":6753,"src_start":6547},{"artifact":1,"gen_end":9602,"gen_start":9206,"node":173,"role":"declaration","source":0,"src_end":7051,"src_start":6755},{"artifact":1,"gen_end":10154,"gen_start":9602,"node":174,"role":"declaration","source":0,"src_end":7487,"src_start":7053},{"artifact":1,"gen_end":10467,"gen_start":10154,"node":175,"role":"declaration","source":0,"src_end":7639,"src_start":7489},{"artifact":1,"gen_end":11056,"gen_start":10467,"node":176,"role":"declaration","source":0,"src_end":8112,"src_start":7641},{"artifact":1,"gen_end":11648,"gen_start":11056,"node":177,"role":"declaration","source":0,"src_end":8588,"src_start":8114},{"artifact":1,"gen_end":12112,"gen_start":11648,"node":178,"role":"declaration","source":0,"src_end":8976,"src_start":8590},{"artifact":1,"gen_end":12530,"gen_start":12112,"node":179,"role":"declaration","source":0,"src_end":9280,"src_start":8978},{"artifact":1,"gen_end":13040,"gen_start":12530,"node":180,"role":"declaration","source":0,"src_end":9716,"src_start":9282},{"artifact":1,"gen_end":13716,"gen_start":13040,"node":181,"role":"declaration","source":0,"src_end":10381,"src_start":9718},{"artifact":1,"gen_end":14127,"gen_start":13716,"node":182,"role":"declaration","source":0,"src_end":10679,"src_start":10383},{"artifact":1,"gen_end":15262,"gen_start":14127,"node":183,"role":"declaration","source":0,"src_end":11943,"src_start":10681},{"artifact":1,"gen_end":15775,"gen_start":15262,"node":184,"role":"declaration","source":0,"src_end":12377,"src_start":11945},{"artifact":1,"gen_end":16635,"gen_start":15775,"node":185,"role":"declaration","source":0,"src_end":13311,"src_start":12379},{"artifact":1,"gen_end":17108,"gen_start":16635,"node":186,"role":"declaration","source":0,"src_end":13652,"src_start":13313},{"artifact":1,"gen_end":17506,"gen_start":17108,"node":187,"role":"declaration","source":0,"src_end":13926,"src_start":13654},{"artifact":1,"gen_end":18042,"gen_start":17506,"node":188,"role":"declaration","source":0,"src_end":14392,"src_start":13928},{"artifact":1,"gen_end":18576,"gen_start":18042,"node":189,"role":"declaration","source":0,"src_end":14853,"src_start":14394},{"artifact":1,"gen_end":19104,"gen_start":18576,"node":190,"role":"declaration","source":0,"src_end":15279,"src_start":14855},{"artifact":1,"gen_end":19530,"gen_start":19104,"node":191,"role":"declaration","source":0,"src_end":15568,"src_start":15281},{"artifact":1,"gen_end":19916,"gen_start":19530,"node":192,"role":"declaration","source":0,"src_end":15819,"src_start":15570},{"artifact":1,"gen_end":20283,"gen_start":19916,"node":193,"role":"declaration","source":0,"src_end":16055,"src_start":15821},{"artifact":1,"gen_end":20964,"gen_start":20283,"node":194,"role":"declaration","source":0,"src_end":16604,"src_start":16057},{"artifact":1,"gen_end":21372,"gen_start":20964,"node":195,"role":"declaration","source":0,"src_end":16892,"src_start":16606},{"artifact":1,"gen_end":21753,"gen_start":21372,"node":196,"role":"declaration","source":0,"src_end":17153,"src_start":16894},{"artifact":1,"gen_end":22219,"gen_start":21753,"node":197,"role":"declaration","source":0,"src_end":17490,"src_start":17155},{"artifact":1,"gen_end":22714,"gen_start":22219,"node":198,"role":"declaration","source":0,"src_end":17847,"src_start":17492},{"artifact":1,"gen_end":23198,"gen_start":22714,"node":199,"role":"declaration","source":0,"src_end":18200,"src_start":17849},{"artifact":1,"gen_end":23622,"gen_start":23198,"node":200,"role":"declaration","source":0,"src_end":18473,"src_start":18202},{"artifact":1,"gen_end":24183,"gen_start":23622,"node":201,"role":"declaration","source":0,"src_end":18856,"src_start":18475},{"artifact":1,"gen_end":24435,"gen_start":24183,"node":202,"role":"declaration","source":0,"src_end":19040,"src_start":18858},{"artifact":1,"gen_end":24622,"gen_start":24435,"node":203,"role":"declaration","source":0,"src_end":19159,"src_start":19042},{"artifact":1,"gen_end":24809,"gen_start":24622,"node":204,"role":"declaration","source":0,"src_end":19278,"src_start":19161},{"artifact":1,"gen_end":25003,"gen_start":24809,"node":205,"role":"declaration","source":0,"src_end":19402,"src_start":19280},{"artifact":1,"gen_end":25197,"gen_start":25003,"node":206,"role":"declaration","source":0,"src_end":19526,"src_start":19404},{"artifact":1,"gen_end":25458,"gen_start":25197,"node":207,"role":"declaration","source":0,"src_end":19713,"src_start":19528},{"artifact":1,"gen_end":25720,"gen_start":25458,"node":208,"role":"declaration","source":0,"src_end":19901,"src_start":19715},{"artifact":1,"gen_end":25996,"gen_start":25720,"node":209,"role":"declaration","source":0,"src_end":20056,"src_start":19903},{"artifact":1,"gen_end":26272,"gen_start":25996,"node":210,"role":"declaration","source":0,"src_end":20211,"src_start":20058},{"artifact":1,"gen_end":26583,"gen_start":26272,"node":211,"role":"declaration","source":0,"src_end":21190,"src_start":20213},{"artifact":1,"gen_end":26931,"gen_start":26583,"node":212,"role":"declaration","source":0,"src_end":21712,"src_start":21192},{"artifact":1,"gen_end":27335,"gen_start":26931,"node":213,"role":"declaration","source":0,"src_end":22295,"src_start":21714},{"artifact":1,"gen_end":27617,"gen_start":27335,"node":214,"role":"declaration","source":0,"src_end":22759,"src_start":22297},{"artifact":1,"gen_end":27930,"gen_start":27617,"node":215,"role":"declaration","source":0,"src_end":23265,"src_start":22761},{"artifact":1,"gen_end":28288,"gen_start":27930,"node":216,"role":"declaration","source":0,"src_end":23814,"src_start":23267},{"artifact":1,"gen_end":28636,"gen_start":28288,"node":217,"role":"declaration","source":0,"src_end":24357,"src_start":23816},{"artifact":1,"gen_end":28995,"gen_start":28636,"node":218,"role":"declaration","source":0,"src_end":24940,"src_start":24359},{"artifact":1,"gen_end":29344,"gen_start":28995,"node":219,"role":"declaration","source":0,"src_end":25526,"src_start":24942},{"artifact":1,"gen_end":29840,"gen_start":29344,"node":220,"role":"declaration","source":0,"src_end":26329,"src_start":25528},{"artifact":1,"gen_end":30343,"gen_start":29840,"node":221,"role":"declaration","source":0,"src_end":27278,"src_start":26331},{"artifact":1,"gen_end":30837,"gen_start":30343,"node":222,"role":"declaration","source":0,"src_end":28114,"src_start":27280},{"artifact":1,"gen_end":31157,"gen_start":30837,"node":223,"role":"declaration","source":0,"src_end":29040,"src_start":28116},{"artifact":1,"gen_end":34190,"gen_start":31157,"node":224,"role":"declaration","source":0,"src_end":32959,"src_start":29042},{"artifact":1,"gen_end":38246,"gen_start":34190,"node":225,"role":"declaration","source":0,"src_end":38890,"src_start":32961},{"artifact":1,"gen_end":39516,"gen_start":38246,"node":226,"role":"declaration","source":0,"src_end":39776,"src_start":38892},{"artifact":1,"gen_end":39954,"gen_start":39516,"node":227,"role":"declaration","source":0,"src_end":40071,"src_start":39778},{"artifact":1,"gen_end":40618,"gen_start":39954,"node":228,"role":"declaration","source":0,"src_end":40526,"src_start":40073},{"artifact":1,"gen_end":71405,"gen_start":40618,"node":229,"role":"declaration","source":0,"src_end":70968,"src_start":40528},{"artifact":1,"gen_end":72091,"gen_start":71405,"node":230,"role":"declaration","source":0,"src_end":71454,"src_start":70970},{"artifact":1,"gen_end":73631,"gen_start":72091,"node":231,"role":"declaration","source":0,"src_end":72731,"src_start":71456},{"artifact":1,"gen_end":74110,"gen_start":73631,"node":232,"role":"declaration","source":0,"src_end":73012,"src_start":72733},{"artifact":1,"gen_end":74564,"gen_start":74110,"node":233,"role":"declaration","source":0,"src_end":73260,"src_start":73014},{"artifact":1,"gen_end":75004,"gen_start":74564,"node":234,"role":"declaration","source":0,"src_end":73497,"src_start":73262},{"artifact":1,"gen_end":77109,"gen_start":75004,"node":235,"role":"declaration","source":0,"src_end":75195,"src_start":73499},{"artifact":1,"gen_end":77639,"gen_start":77109,"node":236,"role":"declaration","source":0,"src_end":75517,"src_start":75197},{"artifact":1,"gen_end":78144,"gen_start":77639,"node":237,"role":"declaration","source":0,"src_end":75814,"src_start":75519},{"artifact":1,"gen_end":78632,"gen_start":78144,"node":238,"role":"declaration","source":0,"src_end":76093,"src_start":75816},{"artifact":1,"gen_end":79140,"gen_start":78632,"node":239,"role":"declaration","source":0,"src_end":76522,"src_start":76095},{"artifact":1,"gen_end":79578,"gen_start":79140,"node":240,"role":"declaration","source":0,"src_end":76871,"src_start":76524},{"artifact":1,"gen_end":80147,"gen_start":79578,"node":241,"role":"declaration","source":0,"src_end":77300,"src_start":76873},{"artifact":1,"gen_end":80611,"gen_start":80147,"node":242,"role":"declaration","source":0,"src_end":77630,"src_start":77302},{"artifact":1,"gen_end":81081,"gen_start":80611,"node":243,"role":"declaration","source":0,"src_end":77959,"src_start":77632},{"artifact":1,"gen_end":81461,"gen_start":81081,"node":244,"role":"declaration","source":0,"src_end":78153,"src_start":77961},{"artifact":1,"gen_end":81984,"gen_start":81461,"node":245,"role":"declaration","source":0,"src_end":78556,"src_start":78155},{"artifact":1,"gen_end":82571,"gen_start":81984,"node":246,"role":"declaration","source":0,"src_end":79042,"src_start":78558},{"artifact":1,"gen_end":83117,"gen_start":82571,"node":247,"role":"declaration","source":0,"src_end":79475,"src_start":79044},{"artifact":1,"gen_end":83446,"gen_start":83117,"node":248,"role":"declaration","source":0,"src_end":79649,"src_start":79477},{"artifact":1,"gen_end":83904,"gen_start":83446,"node":249,"role":"declaration","source":0,"src_end":79961,"src_start":79651},{"artifact":1,"gen_end":84475,"gen_start":83904,"node":250,"role":"declaration","source":0,"src_end":80386,"src_start":79963},{"artifact":1,"gen_end":84822,"gen_start":84475,"node":251,"role":"declaration","source":0,"src_end":80555,"src_start":80388},{"artifact":1,"gen_end":85286,"gen_start":84822,"node":252,"role":"declaration","source":0,"src_end":80871,"src_start":80557},{"artifact":1,"gen_end":85798,"gen_start":85286,"node":253,"role":"declaration","source":0,"src_end":81229,"src_start":80873},{"artifact":1,"gen_end":86304,"gen_start":85798,"node":254,"role":"declaration","source":0,"src_end":81620,"src_start":81231},{"artifact":1,"gen_end":86758,"gen_start":86304,"node":255,"role":"declaration","source":0,"src_end":81928,"src_start":81622},{"artifact":1,"gen_end":87237,"gen_start":86758,"node":256,"role":"declaration","source":0,"src_end":82254,"src_start":81930},{"artifact":1,"gen_end":87653,"gen_start":87237,"node":257,"role":"declaration","source":0,"src_end":82485,"src_start":82256},{"artifact":1,"gen_end":88190,"gen_start":87653,"node":258,"role":"declaration","source":0,"src_end":82856,"src_start":82487},{"artifact":1,"gen_end":88620,"gen_start":88190,"node":259,"role":"declaration","source":0,"src_end":83100,"src_start":82858},{"artifact":1,"gen_end":88945,"gen_start":88620,"node":260,"role":"declaration","source":0,"src_end":83267,"src_start":83102},{"artifact":1,"gen_end":89394,"gen_start":88945,"node":261,"role":"declaration","source":0,"src_end":83570,"src_start":83269},{"artifact":1,"gen_end":89953,"gen_start":89394,"node":262,"role":"declaration","source":0,"src_end":83990,"src_start":83572},{"artifact":1,"gen_end":90422,"gen_start":89953,"node":263,"role":"declaration","source":0,"src_end":84313,"src_start":83992},{"artifact":1,"gen_end":90858,"gen_start":90422,"node":264,"role":"declaration","source":0,"src_end":84579,"src_start":84315},{"artifact":1,"gen_end":91132,"gen_start":90858,"node":265,"role":"declaration","source":0,"src_end":84692,"src_start":84581},{"artifact":1,"gen_end":92747,"gen_start":91132,"node":266,"role":"declaration","source":0,"src_end":86153,"src_start":84694},{"artifact":1,"gen_end":93667,"gen_start":92747,"node":267,"role":"declaration","source":0,"src_end":86989,"src_start":86155},{"artifact":1,"gen_end":94240,"gen_start":93667,"node":268,"role":"declaration","source":0,"src_end":87424,"src_start":86991},{"artifact":1,"gen_end":94721,"gen_start":94240,"node":269,"role":"declaration","source":0,"src_end":87815,"src_start":87426},{"artifact":1,"gen_end":95338,"gen_start":94721,"node":270,"role":"declaration","source":0,"src_end":88306,"src_start":87817},{"artifact":1,"gen_end":95816,"gen_start":95338,"node":271,"role":"declaration","source":0,"src_end":88661,"src_start":88308},{"artifact":1,"gen_end":96683,"gen_start":95816,"node":272,"role":"declaration","source":0,"src_end":89445,"src_start":88663},{"artifact":1,"gen_end":97335,"gen_start":96683,"node":273,"role":"declaration","source":0,"src_end":90031,"src_start":89447},{"artifact":1,"gen_end":98331,"gen_start":97335,"node":274,"role":"declaration","source":0,"src_end":90987,"src_start":90033},{"artifact":1,"gen_end":98982,"gen_start":98331,"node":275,"role":"declaration","source":0,"src_end":91513,"src_start":90989},{"artifact":1,"gen_end":99510,"gen_start":98982,"node":276,"role":"declaration","source":0,"src_end":91889,"src_start":91515},{"artifact":1,"gen_end":100179,"gen_start":99510,"node":277,"role":"declaration","source":0,"src_end":92375,"src_start":91891},{"artifact":1,"gen_end":100939,"gen_start":100179,"node":278,"role":"declaration","source":0,"src_end":92995,"src_start":92377},{"artifact":1,"gen_end":101566,"gen_start":100939,"node":279,"role":"declaration","source":0,"src_end":93423,"src_start":92997},{"artifact":1,"gen_end":102117,"gen_start":101566,"node":280,"role":"declaration","source":0,"src_end":93830,"src_start":93425},{"artifact":1,"gen_end":102775,"gen_start":102117,"node":281,"role":"declaration","source":0,"src_end":94310,"src_start":93832},{"artifact":1,"gen_end":103220,"gen_start":102775,"node":282,"role":"declaration","source":0,"src_end":94650,"src_start":94312},{"artifact":1,"gen_end":103687,"gen_start":103220,"node":283,"role":"declaration","source":0,"src_end":94989,"src_start":94652},{"artifact":1,"gen_end":103992,"gen_start":103687,"node":284,"role":"declaration","source":0,"src_end":95133,"src_start":94991},{"artifact":1,"gen_end":104365,"gen_start":103992,"node":285,"role":"declaration","source":0,"src_end":95333,"src_start":95135},{"artifact":1,"gen_end":104757,"gen_start":104365,"node":286,"role":"declaration","source":0,"src_end":95561,"src_start":95335},{"artifact":1,"gen_end":105049,"gen_start":104757,"node":287,"role":"declaration","source":0,"src_end":95723,"src_start":95563},{"artifact":1,"gen_end":105393,"gen_start":105049,"node":288,"role":"declaration","source":0,"src_end":95896,"src_start":95725},{"artifact":1,"gen_end":105894,"gen_start":105393,"node":289,"role":"declaration","source":0,"src_end":96300,"src_start":95898},{"artifact":1,"gen_end":106412,"gen_start":105894,"node":290,"role":"declaration","source":0,"src_end":96721,"src_start":96302},{"artifact":1,"gen_end":106936,"gen_start":106412,"node":291,"role":"declaration","source":0,"src_end":97113,"src_start":96723},{"artifact":1,"gen_end":107489,"gen_start":106936,"node":292,"role":"declaration","source":0,"src_end":97536,"src_start":97115},{"artifact":1,"gen_end":107910,"gen_start":107489,"node":293,"role":"declaration","source":0,"src_end":97869,"src_start":97538},{"artifact":1,"gen_end":108361,"gen_start":107910,"node":294,"role":"declaration","source":0,"src_end":98230,"src_start":97871},{"artifact":1,"gen_end":108798,"gen_start":108361,"node":295,"role":"declaration","source":0,"src_end":98577,"src_start":98232},{"artifact":1,"gen_end":109432,"gen_start":108798,"node":296,"role":"declaration","source":0,"src_end":99100,"src_start":98579},{"artifact":1,"gen_end":109662,"gen_start":109432,"node":297,"role":"declaration","source":0,"src_end":99250,"src_start":99102},{"artifact":1,"gen_end":109955,"gen_start":109662,"node":298,"role":"declaration","source":0,"src_end":99491,"src_start":99252},{"artifact":1,"gen_end":110327,"gen_start":109955,"node":299,"role":"declaration","source":0,"src_end":99766,"src_start":99493},{"artifact":1,"gen_end":110569,"gen_start":110327,"node":300,"role":"declaration","source":0,"src_end":99965,"src_start":99768},{"artifact":1,"gen_end":110810,"gen_start":110569,"node":301,"role":"declaration","source":0,"src_end":100163,"src_start":99967},{"artifact":1,"gen_end":111054,"gen_start":110810,"node":302,"role":"declaration","source":0,"src_end":100368,"src_start":100165},{"artifact":1,"gen_end":111246,"gen_start":111054,"node":303,"role":"declaration","source":0,"src_end":100497,"src_start":100370},{"artifact":1,"gen_end":111437,"gen_start":111246,"node":304,"role":"declaration","source":0,"src_end":100625,"src_start":100499},{"artifact":1,"gen_end":111692,"gen_start":111437,"node":305,"role":"declaration","source":0,"src_end":100811,"src_start":100627},{"artifact":1,"gen_end":111707,"gen_start":111692,"node":153,"role":"declaration","source":0,"src_end":100847,"src_start":0}],"module":"Gnaf","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-latex-module"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/Gnaf.lex.tex","sha256":"21b9c9174ae33fe77204e196a29a51463f2c9a400f7b305d33591c54f31d798d"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Gnaf.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Gnaf.tex"}],"mappings":[{"artifact":0,"gen_end":324,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":0,"gen_end":1115,"gen_start":324,"node":1,"role":"declaration","source":0,"src_end":1644,"src_start":172},{"artifact":0,"gen_end":1301,"gen_start":1115,"node":2,"role":"declaration","source":0,"src_end":2101,"src_start":1646},{"artifact":0,"gen_end":1389,"gen_start":1301,"node":3,"role":"declaration","source":0,"src_end":2327,"src_start":2103},{"artifact":0,"gen_end":1458,"gen_start":1389,"node":4,"role":"declaration","source":0,"src_end":2471,"src_start":2329},{"artifact":0,"gen_end":1539,"gen_start":1458,"node":5,"role":"declaration","source":0,"src_end":2676,"src_start":2473},{"artifact":0,"gen_end":1597,"gen_start":1539,"node":6,"role":"declaration","source":0,"src_end":2825,"src_start":2678},{"artifact":0,"gen_end":1689,"gen_start":1597,"node":7,"role":"declaration","source":0,"src_end":3036,"src_start":2827},{"artifact":0,"gen_end":1762,"gen_start":1689,"node":8,"role":"declaration","source":0,"src_end":3184,"src_start":3038},{"artifact":0,"gen_end":1934,"gen_start":1762,"node":9,"role":"declaration","source":0,"src_end":3507,"src_start":3186},{"artifact":0,"gen_end":2030,"gen_start":1934,"node":10,"role":"declaration","source":0,"src_end":3670,"src_start":3509},{"artifact":0,"gen_end":2139,"gen_start":2030,"node":11,"role":"declaration","source":0,"src_end":3853,"src_start":3672},{"artifact":0,"gen_end":2303,"gen_start":2139,"node":12,"role":"declaration","source":0,"src_end":4110,"src_start":3855},{"artifact":0,"gen_end":2442,"gen_start":2303,"node":13,"role":"declaration","source":0,"src_end":4401,"src_start":4112},{"artifact":0,"gen_end":2550,"gen_start":2442,"node":14,"role":"declaration","source":0,"src_end":4654,"src_start":4403},{"artifact":0,"gen_end":2638,"gen_start":2550,"node":15,"role":"declaration","source":0,"src_end":4866,"src_start":4656},{"artifact":0,"gen_end":2694,"gen_start":2638,"node":16,"role":"declaration","source":0,"src_end":5013,"src_start":4868},{"artifact":0,"gen_end":2981,"gen_start":2694,"node":17,"role":"declaration","source":0,"src_end":5469,"src_start":5015},{"artifact":0,"gen_end":3597,"gen_start":2981,"node":18,"role":"declaration","source":0,"src_end":6545,"src_start":5471},{"artifact":0,"gen_end":3693,"gen_start":3597,"node":19,"role":"declaration","source":0,"src_end":6753,"src_start":6547},{"artifact":0,"gen_end":3851,"gen_start":3693,"node":20,"role":"declaration","source":0,"src_end":7051,"src_start":6755},{"artifact":0,"gen_end":4221,"gen_start":3851,"node":21,"role":"declaration","source":0,"src_end":7487,"src_start":7053},{"artifact":0,"gen_end":4352,"gen_start":4221,"node":22,"role":"declaration","source":0,"src_end":7639,"src_start":7489},{"artifact":0,"gen_end":4759,"gen_start":4352,"node":23,"role":"declaration","source":0,"src_end":8112,"src_start":7641},{"artifact":0,"gen_end":5169,"gen_start":4759,"node":24,"role":"declaration","source":0,"src_end":8588,"src_start":8114},{"artifact":0,"gen_end":5454,"gen_start":5169,"node":25,"role":"declaration","source":0,"src_end":8976,"src_start":8590},{"artifact":0,"gen_end":5693,"gen_start":5454,"node":26,"role":"declaration","source":0,"src_end":9280,"src_start":8978},{"artifact":0,"gen_end":6018,"gen_start":5693,"node":27,"role":"declaration","source":0,"src_end":9716,"src_start":9282},{"artifact":0,"gen_end":6511,"gen_start":6018,"node":28,"role":"declaration","source":0,"src_end":10381,"src_start":9718},{"artifact":0,"gen_end":6738,"gen_start":6511,"node":29,"role":"declaration","source":0,"src_end":10679,"src_start":10383},{"artifact":0,"gen_end":7691,"gen_start":6738,"node":30,"role":"declaration","source":0,"src_end":11943,"src_start":10681},{"artifact":0,"gen_end":8027,"gen_start":7691,"node":31,"role":"declaration","source":0,"src_end":12377,"src_start":11945},{"artifact":0,"gen_end":8708,"gen_start":8027,"node":32,"role":"declaration","source":0,"src_end":13311,"src_start":12379},{"artifact":0,"gen_end":8999,"gen_start":8708,"node":33,"role":"declaration","source":0,"src_end":13652,"src_start":13313},{"artifact":0,"gen_end":9222,"gen_start":8999,"node":34,"role":"declaration","source":0,"src_end":13926,"src_start":13654},{"artifact":0,"gen_end":9582,"gen_start":9222,"node":35,"role":"declaration","source":0,"src_end":14392,"src_start":13928},{"artifact":0,"gen_end":9941,"gen_start":9582,"node":36,"role":"declaration","source":0,"src_end":14853,"src_start":14394},{"artifact":0,"gen_end":10288,"gen_start":9941,"node":37,"role":"declaration","source":0,"src_end":15279,"src_start":14855},{"artifact":0,"gen_end":10498,"gen_start":10288,"node":38,"role":"declaration","source":0,"src_end":15568,"src_start":15281},{"artifact":0,"gen_end":10687,"gen_start":10498,"node":39,"role":"declaration","source":0,"src_end":15819,"src_start":15570},{"artifact":0,"gen_end":10873,"gen_start":10687,"node":40,"role":"declaration","source":0,"src_end":16055,"src_start":15821},{"artifact":0,"gen_end":11364,"gen_start":10873,"node":41,"role":"declaration","source":0,"src_end":16604,"src_start":16057},{"artifact":0,"gen_end":11595,"gen_start":11364,"node":42,"role":"declaration","source":0,"src_end":16892,"src_start":16606},{"artifact":0,"gen_end":11779,"gen_start":11595,"node":43,"role":"declaration","source":0,"src_end":17153,"src_start":16894},{"artifact":0,"gen_end":12091,"gen_start":11779,"node":44,"role":"declaration","source":0,"src_end":17490,"src_start":17155},{"artifact":0,"gen_end":12434,"gen_start":12091,"node":45,"role":"declaration","source":0,"src_end":17847,"src_start":17492},{"artifact":0,"gen_end":12734,"gen_start":12434,"node":46,"role":"declaration","source":0,"src_end":18200,"src_start":17849},{"artifact":0,"gen_end":12976,"gen_start":12734,"node":47,"role":"declaration","source":0,"src_end":18473,"src_start":18202},{"artifact":0,"gen_end":13351,"gen_start":12976,"node":48,"role":"declaration","source":0,"src_end":18856,"src_start":18475},{"artifact":0,"gen_end":13497,"gen_start":13351,"node":49,"role":"declaration","source":0,"src_end":19040,"src_start":18858},{"artifact":0,"gen_end":13578,"gen_start":13497,"node":50,"role":"declaration","source":0,"src_end":19159,"src_start":19042},{"artifact":0,"gen_end":13659,"gen_start":13578,"node":51,"role":"declaration","source":0,"src_end":19278,"src_start":19161},{"artifact":0,"gen_end":13745,"gen_start":13659,"node":52,"role":"declaration","source":0,"src_end":19402,"src_start":19280},{"artifact":0,"gen_end":13831,"gen_start":13745,"node":53,"role":"declaration","source":0,"src_end":19526,"src_start":19404},{"artifact":0,"gen_end":13980,"gen_start":13831,"node":54,"role":"declaration","source":0,"src_end":19713,"src_start":19528},{"artifact":0,"gen_end":14130,"gen_start":13980,"node":55,"role":"declaration","source":0,"src_end":19901,"src_start":19715},{"artifact":0,"gen_end":14261,"gen_start":14130,"node":56,"role":"declaration","source":0,"src_end":20056,"src_start":19903},{"artifact":0,"gen_end":14392,"gen_start":14261,"node":57,"role":"declaration","source":0,"src_end":20211,"src_start":20058},{"artifact":0,"gen_end":14817,"gen_start":14392,"node":58,"role":"declaration","source":0,"src_end":21190,"src_start":20213},{"artifact":0,"gen_end":15138,"gen_start":14817,"node":59,"role":"declaration","source":0,"src_end":21712,"src_start":21192},{"artifact":0,"gen_end":15520,"gen_start":15138,"node":60,"role":"declaration","source":0,"src_end":22295,"src_start":21714},{"artifact":0,"gen_end":15786,"gen_start":15520,"node":61,"role":"declaration","source":0,"src_end":22759,"src_start":22297},{"artifact":0,"gen_end":16081,"gen_start":15786,"node":62,"role":"declaration","source":0,"src_end":23265,"src_start":22761},{"artifact":0,"gen_end":16423,"gen_start":16081,"node":63,"role":"declaration","source":0,"src_end":23814,"src_start":23267},{"artifact":0,"gen_end":16759,"gen_start":16423,"node":64,"role":"declaration","source":0,"src_end":24357,"src_start":23816},{"artifact":0,"gen_end":17115,"gen_start":16759,"node":65,"role":"declaration","source":0,"src_end":24940,"src_start":24359},{"artifact":0,"gen_end":17471,"gen_start":17115,"node":66,"role":"declaration","source":0,"src_end":25526,"src_start":24942},{"artifact":0,"gen_end":18010,"gen_start":17471,"node":67,"role":"declaration","source":0,"src_end":26329,"src_start":25528},{"artifact":0,"gen_end":18592,"gen_start":18010,"node":68,"role":"declaration","source":0,"src_end":27278,"src_start":26331},{"artifact":0,"gen_end":19102,"gen_start":18592,"node":69,"role":"declaration","source":0,"src_end":28114,"src_start":27280},{"artifact":0,"gen_end":19556,"gen_start":19102,"node":70,"role":"declaration","source":0,"src_end":29040,"src_start":28116},{"artifact":0,"gen_end":22402,"gen_start":19556,"node":71,"role":"declaration","source":0,"src_end":32959,"src_start":29042},{"artifact":0,"gen_end":26270,"gen_start":22402,"node":72,"role":"declaration","source":0,"src_end":38890,"src_start":32961},{"artifact":0,"gen_end":27358,"gen_start":26270,"node":73,"role":"declaration","source":0,"src_end":39776,"src_start":38892},{"artifact":0,"gen_end":27599,"gen_start":27358,"node":74,"role":"declaration","source":0,"src_end":40071,"src_start":39778},{"artifact":0,"gen_end":28077,"gen_start":27599,"node":75,"role":"declaration","source":0,"src_end":40526,"src_start":40073},{"artifact":0,"gen_end":58298,"gen_start":28077,"node":76,"role":"declaration","source":0,"src_end":70968,"src_start":40528},{"artifact":0,"gen_end":58756,"gen_start":58298,"node":77,"role":"declaration","source":0,"src_end":71454,"src_start":70970},{"artifact":0,"gen_end":60041,"gen_start":58756,"node":78,"role":"declaration","source":0,"src_end":72731,"src_start":71456},{"artifact":0,"gen_end":60272,"gen_start":60041,"node":79,"role":"declaration","source":0,"src_end":73012,"src_start":72733},{"artifact":0,"gen_end":60478,"gen_start":60272,"node":80,"role":"declaration","source":0,"src_end":73260,"src_start":73014},{"artifact":0,"gen_end":60670,"gen_start":60478,"node":81,"role":"declaration","source":0,"src_end":73497,"src_start":73262},{"artifact":0,"gen_end":62519,"gen_start":60670,"node":82,"role":"declaration","source":0,"src_end":75195,"src_start":73499},{"artifact":0,"gen_end":62798,"gen_start":62519,"node":83,"role":"declaration","source":0,"src_end":75517,"src_start":75197},{"artifact":0,"gen_end":63052,"gen_start":62798,"node":84,"role":"declaration","source":0,"src_end":75814,"src_start":75519},{"artifact":0,"gen_end":63289,"gen_start":63052,"node":85,"role":"declaration","source":0,"src_end":76093,"src_start":75816},{"artifact":0,"gen_end":63618,"gen_start":63289,"node":86,"role":"declaration","source":0,"src_end":76522,"src_start":76095},{"artifact":0,"gen_end":63877,"gen_start":63618,"node":87,"role":"declaration","source":0,"src_end":76871,"src_start":76524},{"artifact":0,"gen_end":64275,"gen_start":63877,"node":88,"role":"declaration","source":0,"src_end":77300,"src_start":76873},{"artifact":0,"gen_end":64559,"gen_start":64275,"node":89,"role":"declaration","source":0,"src_end":77630,"src_start":77302},{"artifact":0,"gen_end":64874,"gen_start":64559,"node":90,"role":"declaration","source":0,"src_end":77959,"src_start":77632},{"artifact":0,"gen_end":65072,"gen_start":64874,"node":91,"role":"declaration","source":0,"src_end":78153,"src_start":77961},{"artifact":0,"gen_end":65422,"gen_start":65072,"node":92,"role":"declaration","source":0,"src_end":78556,"src_start":78155},{"artifact":0,"gen_end":65850,"gen_start":65422,"node":93,"role":"declaration","source":0,"src_end":79042,"src_start":78558},{"artifact":0,"gen_end":66213,"gen_start":65850,"node":94,"role":"declaration","source":0,"src_end":79475,"src_start":79044},{"artifact":0,"gen_end":66358,"gen_start":66213,"node":95,"role":"declaration","source":0,"src_end":79649,"src_start":79477},{"artifact":0,"gen_end":66602,"gen_start":66358,"node":96,"role":"declaration","source":0,"src_end":79961,"src_start":79651},{"artifact":0,"gen_end":66953,"gen_start":66602,"node":97,"role":"declaration","source":0,"src_end":80386,"src_start":79963},{"artifact":0,"gen_end":67084,"gen_start":66953,"node":98,"role":"declaration","source":0,"src_end":80555,"src_start":80388},{"artifact":0,"gen_end":67333,"gen_start":67084,"node":99,"role":"declaration","source":0,"src_end":80871,"src_start":80557},{"artifact":0,"gen_end":67633,"gen_start":67333,"node":100,"role":"declaration","source":0,"src_end":81229,"src_start":80873},{"artifact":0,"gen_end":67922,"gen_start":67633,"node":101,"role":"declaration","source":0,"src_end":81620,"src_start":81231},{"artifact":0,"gen_end":68177,"gen_start":67922,"node":102,"role":"declaration","source":0,"src_end":81928,"src_start":81622},{"artifact":0,"gen_end":68459,"gen_start":68177,"node":103,"role":"declaration","source":0,"src_end":82254,"src_start":81930},{"artifact":0,"gen_end":68657,"gen_start":68459,"node":104,"role":"declaration","source":0,"src_end":82485,"src_start":82256},{"artifact":0,"gen_end":68976,"gen_start":68657,"node":105,"role":"declaration","source":0,"src_end":82856,"src_start":82487},{"artifact":0,"gen_end":69190,"gen_start":68976,"node":106,"role":"declaration","source":0,"src_end":83100,"src_start":82858},{"artifact":0,"gen_end":69331,"gen_start":69190,"node":107,"role":"declaration","source":0,"src_end":83267,"src_start":83102},{"artifact":0,"gen_end":69566,"gen_start":69331,"node":108,"role":"declaration","source":0,"src_end":83570,"src_start":83269},{"artifact":0,"gen_end":69947,"gen_start":69566,"node":109,"role":"declaration","source":0,"src_end":83990,"src_start":83572},{"artifact":0,"gen_end":70207,"gen_start":69947,"node":110,"role":"declaration","source":0,"src_end":84313,"src_start":83992},{"artifact":0,"gen_end":70426,"gen_start":70207,"node":111,"role":"declaration","source":0,"src_end":84579,"src_start":84315},{"artifact":0,"gen_end":70518,"gen_start":70426,"node":112,"role":"declaration","source":0,"src_end":84692,"src_start":84581},{"artifact":0,"gen_end":71953,"gen_start":70518,"node":113,"role":"declaration","source":0,"src_end":86153,"src_start":84694},{"artifact":0,"gen_end":72649,"gen_start":71953,"node":114,"role":"declaration","source":0,"src_end":86989,"src_start":86155},{"artifact":0,"gen_end":73040,"gen_start":72649,"node":115,"role":"declaration","source":0,"src_end":87424,"src_start":86991},{"artifact":0,"gen_end":73320,"gen_start":73040,"node":116,"role":"declaration","source":0,"src_end":87815,"src_start":87426},{"artifact":0,"gen_end":73738,"gen_start":73320,"node":117,"role":"declaration","source":0,"src_end":88306,"src_start":87817},{"artifact":0,"gen_end":74019,"gen_start":73738,"node":118,"role":"declaration","source":0,"src_end":88661,"src_start":88308},{"artifact":0,"gen_end":74661,"gen_start":74019,"node":119,"role":"declaration","source":0,"src_end":89445,"src_start":88663},{"artifact":0,"gen_end":75089,"gen_start":74661,"node":120,"role":"declaration","source":0,"src_end":90031,"src_start":89447},{"artifact":0,"gen_end":75854,"gen_start":75089,"node":121,"role":"declaration","source":0,"src_end":90987,"src_start":90033},{"artifact":0,"gen_end":76281,"gen_start":75854,"node":122,"role":"declaration","source":0,"src_end":91513,"src_start":90989},{"artifact":0,"gen_end":76626,"gen_start":76281,"node":123,"role":"declaration","source":0,"src_end":91889,"src_start":91515},{"artifact":0,"gen_end":77071,"gen_start":76626,"node":124,"role":"declaration","source":0,"src_end":92375,"src_start":91891},{"artifact":0,"gen_end":77645,"gen_start":77071,"node":125,"role":"declaration","source":0,"src_end":92995,"src_start":92377},{"artifact":0,"gen_end":78103,"gen_start":77645,"node":126,"role":"declaration","source":0,"src_end":93423,"src_start":92997},{"artifact":0,"gen_end":78477,"gen_start":78103,"node":127,"role":"declaration","source":0,"src_end":93830,"src_start":93425},{"artifact":0,"gen_end":79004,"gen_start":78477,"node":128,"role":"declaration","source":0,"src_end":94310,"src_start":93832},{"artifact":0,"gen_end":79268,"gen_start":79004,"node":129,"role":"declaration","source":0,"src_end":94650,"src_start":94312},{"artifact":0,"gen_end":79572,"gen_start":79268,"node":130,"role":"declaration","source":0,"src_end":94989,"src_start":94652},{"artifact":0,"gen_end":79695,"gen_start":79572,"node":131,"role":"declaration","source":0,"src_end":95133,"src_start":94991},{"artifact":0,"gen_end":79886,"gen_start":79695,"node":132,"role":"declaration","source":0,"src_end":95333,"src_start":95135},{"artifact":0,"gen_end":80096,"gen_start":79886,"node":133,"role":"declaration","source":0,"src_end":95561,"src_start":95335},{"artifact":0,"gen_end":80242,"gen_start":80096,"node":134,"role":"declaration","source":0,"src_end":95723,"src_start":95563},{"artifact":0,"gen_end":80404,"gen_start":80242,"node":135,"role":"declaration","source":0,"src_end":95896,"src_start":95725},{"artifact":0,"gen_end":80796,"gen_start":80404,"node":136,"role":"declaration","source":0,"src_end":96300,"src_start":95898},{"artifact":0,"gen_end":81205,"gen_start":80796,"node":137,"role":"declaration","source":0,"src_end":96721,"src_start":96302},{"artifact":0,"gen_end":81620,"gen_start":81205,"node":138,"role":"declaration","source":0,"src_end":97113,"src_start":96723},{"artifact":0,"gen_end":82064,"gen_start":81620,"node":139,"role":"declaration","source":0,"src_end":97536,"src_start":97115},{"artifact":0,"gen_end":82376,"gen_start":82064,"node":140,"role":"declaration","source":0,"src_end":97869,"src_start":97538},{"artifact":0,"gen_end":82718,"gen_start":82376,"node":141,"role":"declaration","source":0,"src_end":98230,"src_start":97871},{"artifact":0,"gen_end":83046,"gen_start":82718,"node":142,"role":"declaration","source":0,"src_end":98577,"src_start":98232},{"artifact":0,"gen_end":83571,"gen_start":83046,"node":143,"role":"declaration","source":0,"src_end":99100,"src_start":98579},{"artifact":0,"gen_end":83692,"gen_start":83571,"node":144,"role":"declaration","source":0,"src_end":99250,"src_start":99102},{"artifact":0,"gen_end":83876,"gen_start":83692,"node":145,"role":"declaration","source":0,"src_end":99491,"src_start":99252},{"artifact":0,"gen_end":84139,"gen_start":83876,"node":146,"role":"declaration","source":0,"src_end":99766,"src_start":99493},{"artifact":0,"gen_end":84272,"gen_start":84139,"node":147,"role":"declaration","source":0,"src_end":99965,"src_start":99768},{"artifact":0,"gen_end":84404,"gen_start":84272,"node":148,"role":"declaration","source":0,"src_end":100163,"src_start":99967},{"artifact":0,"gen_end":84539,"gen_start":84404,"node":149,"role":"declaration","source":0,"src_end":100368,"src_start":100165},{"artifact":0,"gen_end":84622,"gen_start":84539,"node":150,"role":"declaration","source":0,"src_end":100497,"src_start":100370},{"artifact":0,"gen_end":84704,"gen_start":84622,"node":151,"role":"declaration","source":0,"src_end":100625,"src_start":100499},{"artifact":0,"gen_end":84850,"gen_start":84704,"node":152,"role":"declaration","source":0,"src_end":100811,"src_start":100627},{"artifact":0,"gen_end":84874,"gen_start":84850,"node":0,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":153,"role":"declaration","source":0,"src_end":100847,"src_start":0},{"artifact":1,"gen_end":2330,"gen_start":134,"node":154,"role":"declaration","source":0,"src_end":1644,"src_start":172},{"artifact":1,"gen_end":3005,"gen_start":2330,"node":155,"role":"declaration","source":0,"src_end":2101,"src_start":1646},{"artifact":1,"gen_end":3305,"gen_start":3005,"node":156,"role":"declaration","source":0,"src_end":2327,"src_start":2103},{"artifact":1,"gen_end":3485,"gen_start":3305,"node":157,"role":"declaration","source":0,"src_end":2471,"src_start":2329},{"artifact":1,"gen_end":3740,"gen_start":3485,"node":158,"role":"declaration","source":0,"src_end":2676,"src_start":2473},{"artifact":1,"gen_end":3927,"gen_start":3740,"node":159,"role":"declaration","source":0,"src_end":2825,"src_start":2678},{"artifact":1,"gen_end":4202,"gen_start":3927,"node":160,"role":"declaration","source":0,"src_end":3036,"src_start":2827},{"artifact":1,"gen_end":4386,"gen_start":4202,"node":161,"role":"declaration","source":0,"src_end":3184,"src_start":3038},{"artifact":1,"gen_end":4813,"gen_start":4386,"node":162,"role":"declaration","source":0,"src_end":3507,"src_start":3186},{"artifact":1,"gen_end":5014,"gen_start":4813,"node":163,"role":"declaration","source":0,"src_end":3670,"src_start":3509},{"artifact":1,"gen_end":5234,"gen_start":5014,"node":164,"role":"declaration","source":0,"src_end":3853,"src_start":3672},{"artifact":1,"gen_end":5581,"gen_start":5234,"node":165,"role":"declaration","source":0,"src_end":4110,"src_start":3855},{"artifact":1,"gen_end":5970,"gen_start":5581,"node":166,"role":"declaration","source":0,"src_end":4401,"src_start":4112},{"artifact":1,"gen_end":6297,"gen_start":5970,"node":167,"role":"declaration","source":0,"src_end":4654,"src_start":4403},{"artifact":1,"gen_end":6559,"gen_start":6297,"node":168,"role":"declaration","source":0,"src_end":4866,"src_start":4656},{"artifact":1,"gen_end":6744,"gen_start":6559,"node":169,"role":"declaration","source":0,"src_end":5013,"src_start":4868},{"artifact":1,"gen_end":7390,"gen_start":6744,"node":170,"role":"declaration","source":0,"src_end":5469,"src_start":5015},{"artifact":1,"gen_end":8948,"gen_start":7390,"node":171,"role":"declaration","source":0,"src_end":6545,"src_start":5471},{"artifact":1,"gen_end":9206,"gen_start":8948,"node":172,"role":"declaration","source":0,"src_end":6753,"src_start":6547},{"artifact":1,"gen_end":9602,"gen_start":9206,"node":173,"role":"declaration","source":0,"src_end":7051,"src_start":6755},{"artifact":1,"gen_end":10154,"gen_start":9602,"node":174,"role":"declaration","source":0,"src_end":7487,"src_start":7053},{"artifact":1,"gen_end":10467,"gen_start":10154,"node":175,"role":"declaration","source":0,"src_end":7639,"src_start":7489},{"artifact":1,"gen_end":11056,"gen_start":10467,"node":176,"role":"declaration","source":0,"src_end":8112,"src_start":7641},{"artifact":1,"gen_end":11648,"gen_start":11056,"node":177,"role":"declaration","source":0,"src_end":8588,"src_start":8114},{"artifact":1,"gen_end":12112,"gen_start":11648,"node":178,"role":"declaration","source":0,"src_end":8976,"src_start":8590},{"artifact":1,"gen_end":12530,"gen_start":12112,"node":179,"role":"declaration","source":0,"src_end":9280,"src_start":8978},{"artifact":1,"gen_end":13040,"gen_start":12530,"node":180,"role":"declaration","source":0,"src_end":9716,"src_start":9282},{"artifact":1,"gen_end":13716,"gen_start":13040,"node":181,"role":"declaration","source":0,"src_end":10381,"src_start":9718},{"artifact":1,"gen_end":14127,"gen_start":13716,"node":182,"role":"declaration","source":0,"src_end":10679,"src_start":10383},{"artifact":1,"gen_end":15262,"gen_start":14127,"node":183,"role":"declaration","source":0,"src_end":11943,"src_start":10681},{"artifact":1,"gen_end":15775,"gen_start":15262,"node":184,"role":"declaration","source":0,"src_end":12377,"src_start":11945},{"artifact":1,"gen_end":16635,"gen_start":15775,"node":185,"role":"declaration","source":0,"src_end":13311,"src_start":12379},{"artifact":1,"gen_end":17108,"gen_start":16635,"node":186,"role":"declaration","source":0,"src_end":13652,"src_start":13313},{"artifact":1,"gen_end":17506,"gen_start":17108,"node":187,"role":"declaration","source":0,"src_end":13926,"src_start":13654},{"artifact":1,"gen_end":18042,"gen_start":17506,"node":188,"role":"declaration","source":0,"src_end":14392,"src_start":13928},{"artifact":1,"gen_end":18576,"gen_start":18042,"node":189,"role":"declaration","source":0,"src_end":14853,"src_start":14394},{"artifact":1,"gen_end":19104,"gen_start":18576,"node":190,"role":"declaration","source":0,"src_end":15279,"src_start":14855},{"artifact":1,"gen_end":19530,"gen_start":19104,"node":191,"role":"declaration","source":0,"src_end":15568,"src_start":15281},{"artifact":1,"gen_end":19916,"gen_start":19530,"node":192,"role":"declaration","source":0,"src_end":15819,"src_start":15570},{"artifact":1,"gen_end":20283,"gen_start":19916,"node":193,"role":"declaration","source":0,"src_end":16055,"src_start":15821},{"artifact":1,"gen_end":20964,"gen_start":20283,"node":194,"role":"declaration","source":0,"src_end":16604,"src_start":16057},{"artifact":1,"gen_end":21372,"gen_start":20964,"node":195,"role":"declaration","source":0,"src_end":16892,"src_start":16606},{"artifact":1,"gen_end":21753,"gen_start":21372,"node":196,"role":"declaration","source":0,"src_end":17153,"src_start":16894},{"artifact":1,"gen_end":22219,"gen_start":21753,"node":197,"role":"declaration","source":0,"src_end":17490,"src_start":17155},{"artifact":1,"gen_end":22714,"gen_start":22219,"node":198,"role":"declaration","source":0,"src_end":17847,"src_start":17492},{"artifact":1,"gen_end":23198,"gen_start":22714,"node":199,"role":"declaration","source":0,"src_end":18200,"src_start":17849},{"artifact":1,"gen_end":23622,"gen_start":23198,"node":200,"role":"declaration","source":0,"src_end":18473,"src_start":18202},{"artifact":1,"gen_end":24183,"gen_start":23622,"node":201,"role":"declaration","source":0,"src_end":18856,"src_start":18475},{"artifact":1,"gen_end":24435,"gen_start":24183,"node":202,"role":"declaration","source":0,"src_end":19040,"src_start":18858},{"artifact":1,"gen_end":24622,"gen_start":24435,"node":203,"role":"declaration","source":0,"src_end":19159,"src_start":19042},{"artifact":1,"gen_end":24809,"gen_start":24622,"node":204,"role":"declaration","source":0,"src_end":19278,"src_start":19161},{"artifact":1,"gen_end":25003,"gen_start":24809,"node":205,"role":"declaration","source":0,"src_end":19402,"src_start":19280},{"artifact":1,"gen_end":25197,"gen_start":25003,"node":206,"role":"declaration","source":0,"src_end":19526,"src_start":19404},{"artifact":1,"gen_end":25458,"gen_start":25197,"node":207,"role":"declaration","source":0,"src_end":19713,"src_start":19528},{"artifact":1,"gen_end":25720,"gen_start":25458,"node":208,"role":"declaration","source":0,"src_end":19901,"src_start":19715},{"artifact":1,"gen_end":25996,"gen_start":25720,"node":209,"role":"declaration","source":0,"src_end":20056,"src_start":19903},{"artifact":1,"gen_end":26272,"gen_start":25996,"node":210,"role":"declaration","source":0,"src_end":20211,"src_start":20058},{"artifact":1,"gen_end":26583,"gen_start":26272,"node":211,"role":"declaration","source":0,"src_end":21190,"src_start":20213},{"artifact":1,"gen_end":26931,"gen_start":26583,"node":212,"role":"declaration","source":0,"src_end":21712,"src_start":21192},{"artifact":1,"gen_end":27335,"gen_start":26931,"node":213,"role":"declaration","source":0,"src_end":22295,"src_start":21714},{"artifact":1,"gen_end":27617,"gen_start":27335,"node":214,"role":"declaration","source":0,"src_end":22759,"src_start":22297},{"artifact":1,"gen_end":27930,"gen_start":27617,"node":215,"role":"declaration","source":0,"src_end":23265,"src_start":22761},{"artifact":1,"gen_end":28288,"gen_start":27930,"node":216,"role":"declaration","source":0,"src_end":23814,"src_start":23267},{"artifact":1,"gen_end":28636,"gen_start":28288,"node":217,"role":"declaration","source":0,"src_end":24357,"src_start":23816},{"artifact":1,"gen_end":28995,"gen_start":28636,"node":218,"role":"declaration","source":0,"src_end":24940,"src_start":24359},{"artifact":1,"gen_end":29344,"gen_start":28995,"node":219,"role":"declaration","source":0,"src_end":25526,"src_start":24942},{"artifact":1,"gen_end":29840,"gen_start":29344,"node":220,"role":"declaration","source":0,"src_end":26329,"src_start":25528},{"artifact":1,"gen_end":30343,"gen_start":29840,"node":221,"role":"declaration","source":0,"src_end":27278,"src_start":26331},{"artifact":1,"gen_end":30837,"gen_start":30343,"node":222,"role":"declaration","source":0,"src_end":28114,"src_start":27280},{"artifact":1,"gen_end":31157,"gen_start":30837,"node":223,"role":"declaration","source":0,"src_end":29040,"src_start":28116},{"artifact":1,"gen_end":34190,"gen_start":31157,"node":224,"role":"declaration","source":0,"src_end":32959,"src_start":29042},{"artifact":1,"gen_end":38246,"gen_start":34190,"node":225,"role":"declaration","source":0,"src_end":38890,"src_start":32961},{"artifact":1,"gen_end":39516,"gen_start":38246,"node":226,"role":"declaration","source":0,"src_end":39776,"src_start":38892},{"artifact":1,"gen_end":39954,"gen_start":39516,"node":227,"role":"declaration","source":0,"src_end":40071,"src_start":39778},{"artifact":1,"gen_end":40618,"gen_start":39954,"node":228,"role":"declaration","source":0,"src_end":40526,"src_start":40073},{"artifact":1,"gen_end":71405,"gen_start":40618,"node":229,"role":"declaration","source":0,"src_end":70968,"src_start":40528},{"artifact":1,"gen_end":72091,"gen_start":71405,"node":230,"role":"declaration","source":0,"src_end":71454,"src_start":70970},{"artifact":1,"gen_end":73631,"gen_start":72091,"node":231,"role":"declaration","source":0,"src_end":72731,"src_start":71456},{"artifact":1,"gen_end":74110,"gen_start":73631,"node":232,"role":"declaration","source":0,"src_end":73012,"src_start":72733},{"artifact":1,"gen_end":74564,"gen_start":74110,"node":233,"role":"declaration","source":0,"src_end":73260,"src_start":73014},{"artifact":1,"gen_end":75004,"gen_start":74564,"node":234,"role":"declaration","source":0,"src_end":73497,"src_start":73262},{"artifact":1,"gen_end":77109,"gen_start":75004,"node":235,"role":"declaration","source":0,"src_end":75195,"src_start":73499},{"artifact":1,"gen_end":77639,"gen_start":77109,"node":236,"role":"declaration","source":0,"src_end":75517,"src_start":75197},{"artifact":1,"gen_end":78144,"gen_start":77639,"node":237,"role":"declaration","source":0,"src_end":75814,"src_start":75519},{"artifact":1,"gen_end":78632,"gen_start":78144,"node":238,"role":"declaration","source":0,"src_end":76093,"src_start":75816},{"artifact":1,"gen_end":79140,"gen_start":78632,"node":239,"role":"declaration","source":0,"src_end":76522,"src_start":76095},{"artifact":1,"gen_end":79578,"gen_start":79140,"node":240,"role":"declaration","source":0,"src_end":76871,"src_start":76524},{"artifact":1,"gen_end":80147,"gen_start":79578,"node":241,"role":"declaration","source":0,"src_end":77300,"src_start":76873},{"artifact":1,"gen_end":80611,"gen_start":80147,"node":242,"role":"declaration","source":0,"src_end":77630,"src_start":77302},{"artifact":1,"gen_end":81081,"gen_start":80611,"node":243,"role":"declaration","source":0,"src_end":77959,"src_start":77632},{"artifact":1,"gen_end":81461,"gen_start":81081,"node":244,"role":"declaration","source":0,"src_end":78153,"src_start":77961},{"artifact":1,"gen_end":81984,"gen_start":81461,"node":245,"role":"declaration","source":0,"src_end":78556,"src_start":78155},{"artifact":1,"gen_end":82571,"gen_start":81984,"node":246,"role":"declaration","source":0,"src_end":79042,"src_start":78558},{"artifact":1,"gen_end":83117,"gen_start":82571,"node":247,"role":"declaration","source":0,"src_end":79475,"src_start":79044},{"artifact":1,"gen_end":83446,"gen_start":83117,"node":248,"role":"declaration","source":0,"src_end":79649,"src_start":79477},{"artifact":1,"gen_end":83904,"gen_start":83446,"node":249,"role":"declaration","source":0,"src_end":79961,"src_start":79651},{"artifact":1,"gen_end":84475,"gen_start":83904,"node":250,"role":"declaration","source":0,"src_end":80386,"src_start":79963},{"artifact":1,"gen_end":84822,"gen_start":84475,"node":251,"role":"declaration","source":0,"src_end":80555,"src_start":80388},{"artifact":1,"gen_end":85286,"gen_start":84822,"node":252,"role":"declaration","source":0,"src_end":80871,"src_start":80557},{"artifact":1,"gen_end":85798,"gen_start":85286,"node":253,"role":"declaration","source":0,"src_end":81229,"src_start":80873},{"artifact":1,"gen_end":86304,"gen_start":85798,"node":254,"role":"declaration","source":0,"src_end":81620,"src_start":81231},{"artifact":1,"gen_end":86758,"gen_start":86304,"node":255,"role":"declaration","source":0,"src_end":81928,"src_start":81622},{"artifact":1,"gen_end":87237,"gen_start":86758,"node":256,"role":"declaration","source":0,"src_end":82254,"src_start":81930},{"artifact":1,"gen_end":87653,"gen_start":87237,"node":257,"role":"declaration","source":0,"src_end":82485,"src_start":82256},{"artifact":1,"gen_end":88190,"gen_start":87653,"node":258,"role":"declaration","source":0,"src_end":82856,"src_start":82487},{"artifact":1,"gen_end":88620,"gen_start":88190,"node":259,"role":"declaration","source":0,"src_end":83100,"src_start":82858},{"artifact":1,"gen_end":88945,"gen_start":88620,"node":260,"role":"declaration","source":0,"src_end":83267,"src_start":83102},{"artifact":1,"gen_end":89394,"gen_start":88945,"node":261,"role":"declaration","source":0,"src_end":83570,"src_start":83269},{"artifact":1,"gen_end":89953,"gen_start":89394,"node":262,"role":"declaration","source":0,"src_end":83990,"src_start":83572},{"artifact":1,"gen_end":90422,"gen_start":89953,"node":263,"role":"declaration","source":0,"src_end":84313,"src_start":83992},{"artifact":1,"gen_end":90858,"gen_start":90422,"node":264,"role":"declaration","source":0,"src_end":84579,"src_start":84315},{"artifact":1,"gen_end":91132,"gen_start":90858,"node":265,"role":"declaration","source":0,"src_end":84692,"src_start":84581},{"artifact":1,"gen_end":92747,"gen_start":91132,"node":266,"role":"declaration","source":0,"src_end":86153,"src_start":84694},{"artifact":1,"gen_end":93667,"gen_start":92747,"node":267,"role":"declaration","source":0,"src_end":86989,"src_start":86155},{"artifact":1,"gen_end":94240,"gen_start":93667,"node":268,"role":"declaration","source":0,"src_end":87424,"src_start":86991},{"artifact":1,"gen_end":94721,"gen_start":94240,"node":269,"role":"declaration","source":0,"src_end":87815,"src_start":87426},{"artifact":1,"gen_end":95338,"gen_start":94721,"node":270,"role":"declaration","source":0,"src_end":88306,"src_start":87817},{"artifact":1,"gen_end":95816,"gen_start":95338,"node":271,"role":"declaration","source":0,"src_end":88661,"src_start":88308},{"artifact":1,"gen_end":96683,"gen_start":95816,"node":272,"role":"declaration","source":0,"src_end":89445,"src_start":88663},{"artifact":1,"gen_end":97335,"gen_start":96683,"node":273,"role":"declaration","source":0,"src_end":90031,"src_start":89447},{"artifact":1,"gen_end":98331,"gen_start":97335,"node":274,"role":"declaration","source":0,"src_end":90987,"src_start":90033},{"artifact":1,"gen_end":98982,"gen_start":98331,"node":275,"role":"declaration","source":0,"src_end":91513,"src_start":90989},{"artifact":1,"gen_end":99510,"gen_start":98982,"node":276,"role":"declaration","source":0,"src_end":91889,"src_start":91515},{"artifact":1,"gen_end":100179,"gen_start":99510,"node":277,"role":"declaration","source":0,"src_end":92375,"src_start":91891},{"artifact":1,"gen_end":100939,"gen_start":100179,"node":278,"role":"declaration","source":0,"src_end":92995,"src_start":92377},{"artifact":1,"gen_end":101566,"gen_start":100939,"node":279,"role":"declaration","source":0,"src_end":93423,"src_start":92997},{"artifact":1,"gen_end":102117,"gen_start":101566,"node":280,"role":"declaration","source":0,"src_end":93830,"src_start":93425},{"artifact":1,"gen_end":102775,"gen_start":102117,"node":281,"role":"declaration","source":0,"src_end":94310,"src_start":93832},{"artifact":1,"gen_end":103220,"gen_start":102775,"node":282,"role":"declaration","source":0,"src_end":94650,"src_start":94312},{"artifact":1,"gen_end":103687,"gen_start":103220,"node":283,"role":"declaration","source":0,"src_end":94989,"src_start":94652},{"artifact":1,"gen_end":103992,"gen_start":103687,"node":284,"role":"declaration","source":0,"src_end":95133,"src_start":94991},{"artifact":1,"gen_end":104365,"gen_start":103992,"node":285,"role":"declaration","source":0,"src_end":95333,"src_start":95135},{"artifact":1,"gen_end":104757,"gen_start":104365,"node":286,"role":"declaration","source":0,"src_end":95561,"src_start":95335},{"artifact":1,"gen_end":105049,"gen_start":104757,"node":287,"role":"declaration","source":0,"src_end":95723,"src_start":95563},{"artifact":1,"gen_end":105393,"gen_start":105049,"node":288,"role":"declaration","source":0,"src_end":95896,"src_start":95725},{"artifact":1,"gen_end":105894,"gen_start":105393,"node":289,"role":"declaration","source":0,"src_end":96300,"src_start":95898},{"artifact":1,"gen_end":106412,"gen_start":105894,"node":290,"role":"declaration","source":0,"src_end":96721,"src_start":96302},{"artifact":1,"gen_end":106936,"gen_start":106412,"node":291,"role":"declaration","source":0,"src_end":97113,"src_start":96723},{"artifact":1,"gen_end":107489,"gen_start":106936,"node":292,"role":"declaration","source":0,"src_end":97536,"src_start":97115},{"artifact":1,"gen_end":107910,"gen_start":107489,"node":293,"role":"declaration","source":0,"src_end":97869,"src_start":97538},{"artifact":1,"gen_end":108361,"gen_start":107910,"node":294,"role":"declaration","source":0,"src_end":98230,"src_start":97871},{"artifact":1,"gen_end":108798,"gen_start":108361,"node":295,"role":"declaration","source":0,"src_end":98577,"src_start":98232},{"artifact":1,"gen_end":109432,"gen_start":108798,"node":296,"role":"declaration","source":0,"src_end":99100,"src_start":98579},{"artifact":1,"gen_end":109662,"gen_start":109432,"node":297,"role":"declaration","source":0,"src_end":99250,"src_start":99102},{"artifact":1,"gen_end":109955,"gen_start":109662,"node":298,"role":"declaration","source":0,"src_end":99491,"src_start":99252},{"artifact":1,"gen_end":110327,"gen_start":109955,"node":299,"role":"declaration","source":0,"src_end":99766,"src_start":99493},{"artifact":1,"gen_end":110569,"gen_start":110327,"node":300,"role":"declaration","source":0,"src_end":99965,"src_start":99768},{"artifact":1,"gen_end":110810,"gen_start":110569,"node":301,"role":"declaration","source":0,"src_end":100163,"src_start":99967},{"artifact":1,"gen_end":111054,"gen_start":110810,"node":302,"role":"declaration","source":0,"src_end":100368,"src_start":100165},{"artifact":1,"gen_end":111246,"gen_start":111054,"node":303,"role":"declaration","source":0,"src_end":100497,"src_start":100370},{"artifact":1,"gen_end":111437,"gen_start":111246,"node":304,"role":"declaration","source":0,"src_end":100625,"src_start":100499},{"artifact":1,"gen_end":111692,"gen_start":111437,"node":305,"role":"declaration","source":0,"src_end":100811,"src_start":100627},{"artifact":1,"gen_end":111707,"gen_start":111692,"node":153,"role":"declaration","source":0,"src_end":100847,"src_start":0}],"module":"Gnaf","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-latex-module"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/Gnaf.lex.tex","sha256":"21b9c9174ae33fe77204e196a29a51463f2c9a400f7b305d33591c54f31d798d"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/GnafCertificates.map.json b/compiler/expected/build/maps/LexLeanTarget/GnafCertificates.map.json index 54a1b9298..2de70fb39 100644 --- a/compiler/expected/build/maps/LexLeanTarget/GnafCertificates.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/GnafCertificates.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GnafCertificates.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GnafCertificates.tex"}],"mappings":[{"artifact":0,"gen_end":414,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":0,"gen_end":1247,"gen_start":414,"node":1,"role":"declaration","source":0,"src_end":1053,"src_start":261},{"artifact":0,"gen_end":1546,"gen_start":1247,"node":2,"role":"declaration","source":0,"src_end":1401,"src_start":1055},{"artifact":0,"gen_end":2308,"gen_start":1546,"node":3,"role":"declaration","source":0,"src_end":2136,"src_start":1403},{"artifact":0,"gen_end":2653,"gen_start":2308,"node":4,"role":"declaration","source":0,"src_end":2528,"src_start":2138},{"artifact":0,"gen_end":3488,"gen_start":2653,"node":5,"role":"declaration","source":0,"src_end":3324,"src_start":2530},{"artifact":0,"gen_end":3829,"gen_start":3488,"node":6,"role":"declaration","source":0,"src_end":3714,"src_start":3326},{"artifact":0,"gen_end":4664,"gen_start":3829,"node":7,"role":"declaration","source":0,"src_end":4510,"src_start":3716},{"artifact":0,"gen_end":5001,"gen_start":4664,"node":8,"role":"declaration","source":0,"src_end":4898,"src_start":4512},{"artifact":0,"gen_end":6126,"gen_start":5001,"node":9,"role":"declaration","source":0,"src_end":5944,"src_start":4900},{"artifact":0,"gen_end":6465,"gen_start":6126,"node":10,"role":"declaration","source":0,"src_end":6332,"src_start":5946},{"artifact":0,"gen_end":6673,"gen_start":6465,"node":11,"role":"declaration","source":0,"src_end":6613,"src_start":6334},{"artifact":0,"gen_end":7508,"gen_start":6673,"node":12,"role":"declaration","source":0,"src_end":7409,"src_start":6615},{"artifact":0,"gen_end":7856,"gen_start":7508,"node":13,"role":"declaration","source":0,"src_end":7802,"src_start":7411},{"artifact":0,"gen_end":8693,"gen_start":7856,"node":14,"role":"declaration","source":0,"src_end":8598,"src_start":7804},{"artifact":0,"gen_end":9028,"gen_start":8693,"node":15,"role":"declaration","source":0,"src_end":8982,"src_start":8600},{"artifact":0,"gen_end":9962,"gen_start":9028,"node":16,"role":"declaration","source":0,"src_end":9869,"src_start":8984},{"artifact":0,"gen_end":10306,"gen_start":9962,"node":17,"role":"declaration","source":0,"src_end":10262,"src_start":9871},{"artifact":0,"gen_end":11139,"gen_start":10306,"node":18,"role":"declaration","source":0,"src_end":11056,"src_start":10264},{"artifact":0,"gen_end":11474,"gen_start":11139,"node":19,"role":"declaration","source":0,"src_end":11440,"src_start":11058},{"artifact":0,"gen_end":12603,"gen_start":11474,"node":20,"role":"declaration","source":0,"src_end":12487,"src_start":11442},{"artifact":0,"gen_end":12869,"gen_start":12603,"node":21,"role":"declaration","source":0,"src_end":12812,"src_start":12489},{"artifact":0,"gen_end":13673,"gen_start":12869,"node":22,"role":"declaration","source":0,"src_end":13560,"src_start":12814},{"artifact":0,"gen_end":14036,"gen_start":13673,"node":23,"role":"declaration","source":0,"src_end":13972,"src_start":13562},{"artifact":0,"gen_end":14868,"gen_start":14036,"node":24,"role":"declaration","source":0,"src_end":14740,"src_start":13974},{"artifact":0,"gen_end":15218,"gen_start":14868,"node":25,"role":"declaration","source":0,"src_end":15141,"src_start":14742},{"artifact":0,"gen_end":16036,"gen_start":15218,"node":26,"role":"declaration","source":0,"src_end":15891,"src_start":15143},{"artifact":0,"gen_end":16393,"gen_start":16036,"node":27,"role":"declaration","source":0,"src_end":16297,"src_start":15893},{"artifact":0,"gen_end":17223,"gen_start":16393,"node":28,"role":"declaration","source":0,"src_end":17059,"src_start":16299},{"artifact":0,"gen_end":17575,"gen_start":17223,"node":29,"role":"declaration","source":0,"src_end":17460,"src_start":17061},{"artifact":0,"gen_end":18403,"gen_start":17575,"node":30,"role":"declaration","source":0,"src_end":18222,"src_start":17462},{"artifact":0,"gen_end":18759,"gen_start":18403,"node":31,"role":"declaration","source":0,"src_end":18629,"src_start":18224},{"artifact":0,"gen_end":19562,"gen_start":18759,"node":32,"role":"declaration","source":0,"src_end":19372,"src_start":18631},{"artifact":0,"gen_end":19920,"gen_start":19562,"node":33,"role":"declaration","source":0,"src_end":19779,"src_start":19374},{"artifact":0,"gen_end":21009,"gen_start":19920,"node":34,"role":"declaration","source":0,"src_end":20792,"src_start":19781},{"artifact":0,"gen_end":21328,"gen_start":21009,"node":35,"role":"declaration","source":0,"src_end":21164,"src_start":20794},{"artifact":0,"gen_end":22148,"gen_start":21328,"node":36,"role":"declaration","source":0,"src_end":21916,"src_start":21166},{"artifact":0,"gen_end":22502,"gen_start":22148,"node":37,"role":"declaration","source":0,"src_end":22319,"src_start":21918},{"artifact":0,"gen_end":24146,"gen_start":22502,"node":38,"role":"declaration","source":0,"src_end":23855,"src_start":22321},{"artifact":0,"gen_end":24442,"gen_start":24146,"node":39,"role":"declaration","source":0,"src_end":24206,"src_start":23857},{"artifact":0,"gen_end":26086,"gen_start":24442,"node":40,"role":"declaration","source":0,"src_end":25740,"src_start":24208},{"artifact":0,"gen_end":26429,"gen_start":26086,"node":41,"role":"declaration","source":0,"src_end":26132,"src_start":25742},{"artifact":0,"gen_end":27320,"gen_start":26429,"node":42,"role":"declaration","source":0,"src_end":26955,"src_start":26134},{"artifact":0,"gen_end":27681,"gen_start":27320,"node":43,"role":"declaration","source":0,"src_end":27365,"src_start":26957},{"artifact":0,"gen_end":28568,"gen_start":27681,"node":44,"role":"declaration","source":0,"src_end":28182,"src_start":27367},{"artifact":0,"gen_end":28935,"gen_start":28568,"node":45,"role":"declaration","source":0,"src_end":28598,"src_start":28184},{"artifact":0,"gen_end":29752,"gen_start":28935,"node":46,"role":"declaration","source":0,"src_end":29349,"src_start":28600},{"artifact":0,"gen_end":30060,"gen_start":29752,"node":47,"role":"declaration","source":0,"src_end":29712,"src_start":29351},{"artifact":0,"gen_end":31192,"gen_start":30060,"node":48,"role":"declaration","source":0,"src_end":30762,"src_start":29714},{"artifact":0,"gen_end":31491,"gen_start":31192,"node":49,"role":"declaration","source":0,"src_end":31110,"src_start":30764},{"artifact":0,"gen_end":32368,"gen_start":31491,"node":50,"role":"declaration","source":0,"src_end":31915,"src_start":31112},{"artifact":0,"gen_end":32667,"gen_start":32368,"node":51,"role":"declaration","source":0,"src_end":32263,"src_start":31917},{"artifact":0,"gen_end":33801,"gen_start":32667,"node":52,"role":"declaration","source":0,"src_end":33315,"src_start":32265},{"artifact":0,"gen_end":34110,"gen_start":33801,"node":53,"role":"declaration","source":0,"src_end":33673,"src_start":33317},{"artifact":0,"gen_end":35799,"gen_start":34110,"node":54,"role":"declaration","source":0,"src_end":35248,"src_start":33675},{"artifact":0,"gen_end":36090,"gen_start":35799,"node":55,"role":"declaration","source":0,"src_end":35590,"src_start":35250},{"artifact":0,"gen_end":37229,"gen_start":36090,"node":56,"role":"declaration","source":0,"src_end":36649,"src_start":35592},{"artifact":0,"gen_end":37569,"gen_start":37229,"node":57,"role":"declaration","source":0,"src_end":37040,"src_start":36651},{"artifact":0,"gen_end":38752,"gen_start":37569,"node":58,"role":"declaration","source":0,"src_end":38139,"src_start":37042},{"artifact":0,"gen_end":39096,"gen_start":38752,"node":59,"role":"declaration","source":0,"src_end":38532,"src_start":38141},{"artifact":0,"gen_end":40240,"gen_start":39096,"node":60,"role":"declaration","source":0,"src_end":39596,"src_start":38534},{"artifact":0,"gen_end":40586,"gen_start":40240,"node":61,"role":"declaration","source":0,"src_end":39993,"src_start":39598},{"artifact":0,"gen_end":42284,"gen_start":40586,"node":62,"role":"declaration","source":0,"src_end":41577,"src_start":39995},{"artifact":0,"gen_end":42622,"gen_start":42284,"node":63,"role":"declaration","source":0,"src_end":41966,"src_start":41579},{"artifact":0,"gen_end":43421,"gen_start":42622,"node":64,"role":"declaration","source":0,"src_end":42693,"src_start":41968},{"artifact":0,"gen_end":43775,"gen_start":43421,"node":65,"role":"declaration","source":0,"src_end":43090,"src_start":42695},{"artifact":0,"gen_end":44861,"gen_start":43775,"node":66,"role":"declaration","source":0,"src_end":44094,"src_start":43092},{"artifact":0,"gen_end":45217,"gen_start":44861,"node":67,"role":"declaration","source":0,"src_end":44493,"src_start":44096},{"artifact":0,"gen_end":46303,"gen_start":45217,"node":68,"role":"declaration","source":0,"src_end":45497,"src_start":44495},{"artifact":0,"gen_end":46659,"gen_start":46303,"node":69,"role":"declaration","source":0,"src_end":45896,"src_start":45499},{"artifact":0,"gen_end":47790,"gen_start":46659,"node":70,"role":"declaration","source":0,"src_end":46957,"src_start":45898},{"artifact":0,"gen_end":48152,"gen_start":47790,"node":71,"role":"declaration","source":0,"src_end":47362,"src_start":46959},{"artifact":0,"gen_end":49331,"gen_start":48152,"node":72,"role":"declaration","source":0,"src_end":48455,"src_start":47364},{"artifact":0,"gen_end":49602,"gen_start":49331,"node":73,"role":"declaration","source":0,"src_end":48783,"src_start":48457},{"artifact":0,"gen_end":50230,"gen_start":49602,"node":74,"role":"declaration","source":0,"src_end":49359,"src_start":48785},{"artifact":0,"gen_end":50583,"gen_start":50230,"node":75,"role":"declaration","source":0,"src_end":49761,"src_start":49361},{"artifact":0,"gen_end":51754,"gen_start":50583,"node":76,"role":"declaration","source":0,"src_end":50846,"src_start":49763},{"artifact":0,"gen_end":52081,"gen_start":51754,"node":77,"role":"declaration","source":0,"src_end":51224,"src_start":50848},{"artifact":0,"gen_end":53261,"gen_start":52081,"node":78,"role":"declaration","source":0,"src_end":52308,"src_start":51226},{"artifact":0,"gen_end":53565,"gen_start":53261,"node":79,"role":"declaration","source":0,"src_end":52661,"src_start":52310},{"artifact":0,"gen_end":54739,"gen_start":53565,"node":80,"role":"declaration","source":0,"src_end":53765,"src_start":52663},{"artifact":0,"gen_end":55043,"gen_start":54739,"node":81,"role":"declaration","source":0,"src_end":54118,"src_start":53767},{"artifact":0,"gen_end":56067,"gen_start":55043,"node":82,"role":"declaration","source":0,"src_end":55054,"src_start":54120},{"artifact":0,"gen_end":56442,"gen_start":56067,"node":83,"role":"declaration","source":0,"src_end":55472,"src_start":55056},{"artifact":0,"gen_end":57586,"gen_start":56442,"node":84,"role":"declaration","source":0,"src_end":56536,"src_start":55474},{"artifact":0,"gen_end":57948,"gen_start":57586,"node":85,"role":"declaration","source":0,"src_end":56941,"src_start":56538},{"artifact":0,"gen_end":59152,"gen_start":57948,"node":86,"role":"declaration","source":0,"src_end":58083,"src_start":56943},{"artifact":0,"gen_end":59510,"gen_start":59152,"node":87,"role":"declaration","source":0,"src_end":58484,"src_start":58085},{"artifact":0,"gen_end":60540,"gen_start":59510,"node":88,"role":"declaration","source":0,"src_end":59438,"src_start":58486},{"artifact":0,"gen_end":60817,"gen_start":60540,"node":89,"role":"declaration","source":0,"src_end":59772,"src_start":59440},{"artifact":0,"gen_end":61921,"gen_start":60817,"node":90,"role":"declaration","source":0,"src_end":60786,"src_start":59774},{"artifact":0,"gen_end":62275,"gen_start":61921,"node":91,"role":"declaration","source":0,"src_end":61183,"src_start":60788},{"artifact":0,"gen_end":63326,"gen_start":62275,"node":92,"role":"declaration","source":0,"src_end":62128,"src_start":61185},{"artifact":0,"gen_end":63638,"gen_start":63326,"node":93,"role":"declaration","source":0,"src_end":62489,"src_start":62130},{"artifact":0,"gen_end":65372,"gen_start":63638,"node":94,"role":"declaration","source":0,"src_end":64105,"src_start":62491},{"artifact":0,"gen_end":65708,"gen_start":65372,"node":95,"role":"declaration","source":0,"src_end":64484,"src_start":64107},{"artifact":0,"gen_end":67391,"gen_start":65708,"node":96,"role":"declaration","source":0,"src_end":66051,"src_start":64486},{"artifact":0,"gen_end":67728,"gen_start":67391,"node":97,"role":"declaration","source":0,"src_end":66431,"src_start":66053},{"artifact":0,"gen_end":68855,"gen_start":67728,"node":98,"role":"declaration","source":0,"src_end":67476,"src_start":66433},{"artifact":0,"gen_end":69203,"gen_start":68855,"node":99,"role":"declaration","source":0,"src_end":67867,"src_start":67478},{"artifact":0,"gen_end":70328,"gen_start":69203,"node":100,"role":"declaration","source":0,"src_end":68910,"src_start":67869},{"artifact":0,"gen_end":70670,"gen_start":70328,"node":101,"role":"declaration","source":0,"src_end":69295,"src_start":68912},{"artifact":0,"gen_end":71797,"gen_start":70670,"node":102,"role":"declaration","source":0,"src_end":70354,"src_start":69297},{"artifact":0,"gen_end":72161,"gen_start":71797,"node":103,"role":"declaration","source":0,"src_end":70761,"src_start":70356},{"artifact":0,"gen_end":73256,"gen_start":72161,"node":104,"role":"declaration","source":0,"src_end":71762,"src_start":70763},{"artifact":0,"gen_end":73620,"gen_start":73256,"node":105,"role":"declaration","source":0,"src_end":72169,"src_start":71764},{"artifact":0,"gen_end":74499,"gen_start":73620,"node":106,"role":"declaration","source":0,"src_end":72976,"src_start":72171},{"artifact":0,"gen_end":74859,"gen_start":74499,"node":107,"role":"declaration","source":0,"src_end":73379,"src_start":72978},{"artifact":0,"gen_end":75819,"gen_start":74859,"node":108,"role":"declaration","source":0,"src_end":74225,"src_start":73381},{"artifact":0,"gen_end":76164,"gen_start":75819,"node":109,"role":"declaration","source":0,"src_end":74619,"src_start":74227},{"artifact":0,"gen_end":77128,"gen_start":76164,"node":110,"role":"declaration","source":0,"src_end":75469,"src_start":74621},{"artifact":0,"gen_end":77483,"gen_start":77128,"node":111,"role":"declaration","source":0,"src_end":75869,"src_start":75471},{"artifact":0,"gen_end":78444,"gen_start":77483,"node":112,"role":"declaration","source":0,"src_end":76716,"src_start":75871},{"artifact":0,"gen_end":78791,"gen_start":78444,"node":113,"role":"declaration","source":0,"src_end":77112,"src_start":76718},{"artifact":0,"gen_end":79923,"gen_start":78791,"node":114,"role":"declaration","source":0,"src_end":78162,"src_start":77114},{"artifact":0,"gen_end":80201,"gen_start":79923,"node":115,"role":"declaration","source":0,"src_end":78499,"src_start":78164},{"artifact":0,"gen_end":81239,"gen_start":80201,"node":116,"role":"declaration","source":0,"src_end":79443,"src_start":78501},{"artifact":0,"gen_end":81607,"gen_start":81239,"node":117,"role":"declaration","source":0,"src_end":79860,"src_start":79445},{"artifact":0,"gen_end":81840,"gen_start":81607,"node":118,"role":"declaration","source":0,"src_end":80166,"src_start":79862},{"artifact":0,"gen_end":82878,"gen_start":81840,"node":119,"role":"declaration","source":0,"src_end":81114,"src_start":80168},{"artifact":0,"gen_end":83234,"gen_start":82878,"node":120,"role":"declaration","source":0,"src_end":81519,"src_start":81116},{"artifact":0,"gen_end":83454,"gen_start":83234,"node":121,"role":"declaration","source":0,"src_end":81812,"src_start":81521},{"artifact":0,"gen_end":84538,"gen_start":83454,"node":122,"role":"declaration","source":0,"src_end":82794,"src_start":81814},{"artifact":0,"gen_end":84894,"gen_start":84538,"node":123,"role":"declaration","source":0,"src_end":83199,"src_start":82796},{"artifact":0,"gen_end":85115,"gen_start":84894,"node":124,"role":"declaration","source":0,"src_end":83493,"src_start":83201},{"artifact":0,"gen_end":86051,"gen_start":85115,"node":125,"role":"declaration","source":0,"src_end":84351,"src_start":83495},{"artifact":0,"gen_end":86362,"gen_start":86051,"node":126,"role":"declaration","source":0,"src_end":84711,"src_start":84353},{"artifact":0,"gen_end":86577,"gen_start":86362,"node":127,"role":"declaration","source":0,"src_end":84999,"src_start":84713},{"artifact":0,"gen_end":87427,"gen_start":86577,"node":128,"role":"declaration","source":0,"src_end":85787,"src_start":85001},{"artifact":0,"gen_end":87783,"gen_start":87427,"node":129,"role":"declaration","source":0,"src_end":86192,"src_start":85789},{"artifact":0,"gen_end":88624,"gen_start":87783,"node":130,"role":"declaration","source":0,"src_end":86971,"src_start":86194},{"artifact":0,"gen_end":88931,"gen_start":88624,"node":131,"role":"declaration","source":0,"src_end":87331,"src_start":86973},{"artifact":0,"gen_end":89970,"gen_start":88931,"node":132,"role":"declaration","source":0,"src_end":88276,"src_start":87333},{"artifact":0,"gen_end":90285,"gen_start":89970,"node":133,"role":"declaration","source":0,"src_end":88640,"src_start":88278},{"artifact":0,"gen_end":90505,"gen_start":90285,"node":134,"role":"declaration","source":0,"src_end":88933,"src_start":88642},{"artifact":0,"gen_end":91557,"gen_start":90505,"node":135,"role":"declaration","source":0,"src_end":89891,"src_start":88935},{"artifact":0,"gen_end":91914,"gen_start":91557,"node":136,"role":"declaration","source":0,"src_end":90297,"src_start":89893},{"artifact":0,"gen_end":92136,"gen_start":91914,"node":137,"role":"declaration","source":0,"src_end":90592,"src_start":90299},{"artifact":0,"gen_end":93178,"gen_start":92136,"node":138,"role":"declaration","source":0,"src_end":91540,"src_start":90594},{"artifact":0,"gen_end":93488,"gen_start":93178,"node":139,"role":"declaration","source":0,"src_end":91899,"src_start":91542},{"artifact":0,"gen_end":93703,"gen_start":93488,"node":140,"role":"declaration","source":0,"src_end":92187,"src_start":91901},{"artifact":0,"gen_end":94245,"gen_start":93703,"node":141,"role":"declaration","source":0,"src_end":92691,"src_start":92189},{"artifact":0,"gen_end":94572,"gen_start":94245,"node":142,"role":"declaration","source":0,"src_end":93069,"src_start":92693},{"artifact":0,"gen_end":95214,"gen_start":94572,"node":143,"role":"declaration","source":0,"src_end":93661,"src_start":93071},{"artifact":0,"gen_end":95547,"gen_start":95214,"node":144,"role":"declaration","source":0,"src_end":94045,"src_start":93663},{"artifact":0,"gen_end":95768,"gen_start":95547,"node":145,"role":"declaration","source":0,"src_end":94339,"src_start":94047},{"artifact":0,"gen_end":96897,"gen_start":95768,"node":146,"role":"declaration","source":0,"src_end":95386,"src_start":94341},{"artifact":0,"gen_end":97164,"gen_start":96897,"node":147,"role":"declaration","source":0,"src_end":95712,"src_start":95388},{"artifact":0,"gen_end":98293,"gen_start":97164,"node":148,"role":"declaration","source":0,"src_end":96761,"src_start":95714},{"artifact":0,"gen_end":98571,"gen_start":98293,"node":149,"role":"declaration","source":0,"src_end":97098,"src_start":96763},{"artifact":0,"gen_end":99457,"gen_start":98571,"node":150,"role":"declaration","source":0,"src_end":97914,"src_start":97100},{"artifact":0,"gen_end":99747,"gen_start":99457,"node":151,"role":"declaration","source":0,"src_end":98263,"src_start":97916},{"artifact":0,"gen_end":100876,"gen_start":99747,"node":152,"role":"declaration","source":0,"src_end":99310,"src_start":98265},{"artifact":0,"gen_end":101142,"gen_start":100876,"node":153,"role":"declaration","source":0,"src_end":99635,"src_start":99312},{"artifact":0,"gen_end":102273,"gen_start":101142,"node":154,"role":"declaration","source":0,"src_end":100684,"src_start":99637},{"artifact":0,"gen_end":102548,"gen_start":102273,"node":155,"role":"declaration","source":0,"src_end":101018,"src_start":100686},{"artifact":0,"gen_end":102742,"gen_start":102548,"node":156,"role":"declaration","source":0,"src_end":101279,"src_start":101020},{"artifact":0,"gen_end":102938,"gen_start":102742,"node":157,"role":"declaration","source":0,"src_end":101542,"src_start":101281},{"artifact":0,"gen_end":103133,"gen_start":102938,"node":158,"role":"declaration","source":0,"src_end":101804,"src_start":101544},{"artifact":0,"gen_end":103329,"gen_start":103133,"node":159,"role":"declaration","source":0,"src_end":102067,"src_start":101806},{"artifact":0,"gen_end":103523,"gen_start":103329,"node":160,"role":"declaration","source":0,"src_end":102328,"src_start":102069},{"artifact":0,"gen_end":103718,"gen_start":103523,"node":161,"role":"declaration","source":0,"src_end":102590,"src_start":102330},{"artifact":0,"gen_end":103912,"gen_start":103718,"node":162,"role":"declaration","source":0,"src_end":102851,"src_start":102592},{"artifact":0,"gen_end":104108,"gen_start":103912,"node":163,"role":"declaration","source":0,"src_end":103114,"src_start":102853},{"artifact":0,"gen_end":104302,"gen_start":104108,"node":164,"role":"declaration","source":0,"src_end":103375,"src_start":103116},{"artifact":0,"gen_end":104497,"gen_start":104302,"node":165,"role":"declaration","source":0,"src_end":103637,"src_start":103377},{"artifact":0,"gen_end":104677,"gen_start":104497,"node":166,"role":"declaration","source":0,"src_end":103884,"src_start":103639},{"artifact":0,"gen_end":104859,"gen_start":104677,"node":167,"role":"declaration","source":0,"src_end":104133,"src_start":103886},{"artifact":0,"gen_end":105039,"gen_start":104859,"node":168,"role":"declaration","source":0,"src_end":104380,"src_start":104135},{"artifact":0,"gen_end":105220,"gen_start":105039,"node":169,"role":"declaration","source":0,"src_end":104628,"src_start":104382},{"artifact":0,"gen_end":105392,"gen_start":105220,"node":170,"role":"declaration","source":0,"src_end":104867,"src_start":104630},{"artifact":0,"gen_end":105566,"gen_start":105392,"node":171,"role":"declaration","source":0,"src_end":105108,"src_start":104869},{"artifact":0,"gen_end":105738,"gen_start":105566,"node":172,"role":"declaration","source":0,"src_end":105347,"src_start":105110},{"artifact":0,"gen_end":105911,"gen_start":105738,"node":173,"role":"declaration","source":0,"src_end":105587,"src_start":105349},{"artifact":0,"gen_end":105947,"gen_start":105911,"node":0,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":174,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":1,"gen_end":1129,"gen_start":134,"node":175,"role":"declaration","source":0,"src_end":1053,"src_start":261},{"artifact":1,"gen_end":1578,"gen_start":1129,"node":176,"role":"declaration","source":0,"src_end":1401,"src_start":1055},{"artifact":1,"gen_end":2500,"gen_start":1578,"node":177,"role":"declaration","source":0,"src_end":2136,"src_start":1403},{"artifact":1,"gen_end":2995,"gen_start":2500,"node":178,"role":"declaration","source":0,"src_end":2528,"src_start":2138},{"artifact":1,"gen_end":3992,"gen_start":2995,"node":179,"role":"declaration","source":0,"src_end":3324,"src_start":2530},{"artifact":1,"gen_end":4483,"gen_start":3992,"node":180,"role":"declaration","source":0,"src_end":3714,"src_start":3326},{"artifact":1,"gen_end":5480,"gen_start":4483,"node":181,"role":"declaration","source":0,"src_end":4510,"src_start":3716},{"artifact":1,"gen_end":5967,"gen_start":5480,"node":182,"role":"declaration","source":0,"src_end":4898,"src_start":4512},{"artifact":1,"gen_end":7254,"gen_start":5967,"node":183,"role":"declaration","source":0,"src_end":5944,"src_start":4900},{"artifact":1,"gen_end":7743,"gen_start":7254,"node":184,"role":"declaration","source":0,"src_end":6332,"src_start":5946},{"artifact":1,"gen_end":8101,"gen_start":7743,"node":185,"role":"declaration","source":0,"src_end":6613,"src_start":6334},{"artifact":1,"gen_end":9098,"gen_start":8101,"node":186,"role":"declaration","source":0,"src_end":7409,"src_start":6615},{"artifact":1,"gen_end":9596,"gen_start":9098,"node":187,"role":"declaration","source":0,"src_end":7802,"src_start":7411},{"artifact":1,"gen_end":10595,"gen_start":9596,"node":188,"role":"declaration","source":0,"src_end":8598,"src_start":7804},{"artifact":1,"gen_end":11080,"gen_start":10595,"node":189,"role":"declaration","source":0,"src_end":8982,"src_start":8600},{"artifact":1,"gen_end":12176,"gen_start":11080,"node":190,"role":"declaration","source":0,"src_end":9869,"src_start":8984},{"artifact":1,"gen_end":12670,"gen_start":12176,"node":191,"role":"declaration","source":0,"src_end":10262,"src_start":9871},{"artifact":1,"gen_end":13665,"gen_start":12670,"node":192,"role":"declaration","source":0,"src_end":11056,"src_start":10264},{"artifact":1,"gen_end":14150,"gen_start":13665,"node":193,"role":"declaration","source":0,"src_end":11440,"src_start":11058},{"artifact":1,"gen_end":15439,"gen_start":14150,"node":194,"role":"declaration","source":0,"src_end":12487,"src_start":11442},{"artifact":1,"gen_end":15855,"gen_start":15439,"node":195,"role":"declaration","source":0,"src_end":12812,"src_start":12489},{"artifact":1,"gen_end":16819,"gen_start":15855,"node":196,"role":"declaration","source":0,"src_end":13560,"src_start":12814},{"artifact":1,"gen_end":17332,"gen_start":16819,"node":197,"role":"declaration","source":0,"src_end":13972,"src_start":13562},{"artifact":1,"gen_end":18324,"gen_start":17332,"node":198,"role":"declaration","source":0,"src_end":14740,"src_start":13974},{"artifact":1,"gen_end":18824,"gen_start":18324,"node":199,"role":"declaration","source":0,"src_end":15141,"src_start":14742},{"artifact":1,"gen_end":19802,"gen_start":18824,"node":200,"role":"declaration","source":0,"src_end":15891,"src_start":15143},{"artifact":1,"gen_end":20309,"gen_start":19802,"node":201,"role":"declaration","source":0,"src_end":16297,"src_start":15893},{"artifact":1,"gen_end":21299,"gen_start":20309,"node":202,"role":"declaration","source":0,"src_end":17059,"src_start":16299},{"artifact":1,"gen_end":21801,"gen_start":21299,"node":203,"role":"declaration","source":0,"src_end":17460,"src_start":17061},{"artifact":1,"gen_end":22789,"gen_start":21801,"node":204,"role":"declaration","source":0,"src_end":18222,"src_start":17462},{"artifact":1,"gen_end":23295,"gen_start":22789,"node":205,"role":"declaration","source":0,"src_end":18629,"src_start":18224},{"artifact":1,"gen_end":24258,"gen_start":23295,"node":206,"role":"declaration","source":0,"src_end":19372,"src_start":18631},{"artifact":1,"gen_end":24766,"gen_start":24258,"node":207,"role":"declaration","source":0,"src_end":19779,"src_start":19374},{"artifact":1,"gen_end":26015,"gen_start":24766,"node":208,"role":"declaration","source":0,"src_end":20792,"src_start":19781},{"artifact":1,"gen_end":26484,"gen_start":26015,"node":209,"role":"declaration","source":0,"src_end":21164,"src_start":20794},{"artifact":1,"gen_end":27464,"gen_start":26484,"node":210,"role":"declaration","source":0,"src_end":21916,"src_start":21166},{"artifact":1,"gen_end":27968,"gen_start":27464,"node":211,"role":"declaration","source":0,"src_end":22319,"src_start":21918},{"artifact":1,"gen_end":29772,"gen_start":27968,"node":212,"role":"declaration","source":0,"src_end":23855,"src_start":22321},{"artifact":1,"gen_end":30218,"gen_start":29772,"node":213,"role":"declaration","source":0,"src_end":24206,"src_start":23857},{"artifact":1,"gen_end":32022,"gen_start":30218,"node":214,"role":"declaration","source":0,"src_end":25740,"src_start":24208},{"artifact":1,"gen_end":32515,"gen_start":32022,"node":215,"role":"declaration","source":0,"src_end":26132,"src_start":25742},{"artifact":1,"gen_end":33566,"gen_start":32515,"node":216,"role":"declaration","source":0,"src_end":26955,"src_start":26134},{"artifact":1,"gen_end":34077,"gen_start":33566,"node":217,"role":"declaration","source":0,"src_end":27365,"src_start":26957},{"artifact":1,"gen_end":35124,"gen_start":34077,"node":218,"role":"declaration","source":0,"src_end":28182,"src_start":27367},{"artifact":1,"gen_end":35641,"gen_start":35124,"node":219,"role":"declaration","source":0,"src_end":28598,"src_start":28184},{"artifact":1,"gen_end":36618,"gen_start":35641,"node":220,"role":"declaration","source":0,"src_end":29349,"src_start":28600},{"artifact":1,"gen_end":37076,"gen_start":36618,"node":221,"role":"declaration","source":0,"src_end":29712,"src_start":29351},{"artifact":1,"gen_end":38368,"gen_start":37076,"node":222,"role":"declaration","source":0,"src_end":30762,"src_start":29714},{"artifact":1,"gen_end":38817,"gen_start":38368,"node":223,"role":"declaration","source":0,"src_end":31110,"src_start":30764},{"artifact":1,"gen_end":39854,"gen_start":38817,"node":224,"role":"declaration","source":0,"src_end":31915,"src_start":31112},{"artifact":1,"gen_end":40303,"gen_start":39854,"node":225,"role":"declaration","source":0,"src_end":32263,"src_start":31917},{"artifact":1,"gen_end":41597,"gen_start":40303,"node":226,"role":"declaration","source":0,"src_end":33315,"src_start":32265},{"artifact":1,"gen_end":42056,"gen_start":41597,"node":227,"role":"declaration","source":0,"src_end":33673,"src_start":33317},{"artifact":1,"gen_end":43905,"gen_start":42056,"node":228,"role":"declaration","source":0,"src_end":35248,"src_start":33675},{"artifact":1,"gen_end":44346,"gen_start":43905,"node":229,"role":"declaration","source":0,"src_end":35590,"src_start":35250},{"artifact":1,"gen_end":45645,"gen_start":44346,"node":230,"role":"declaration","source":0,"src_end":36649,"src_start":35592},{"artifact":1,"gen_end":46135,"gen_start":45645,"node":231,"role":"declaration","source":0,"src_end":37040,"src_start":36651},{"artifact":1,"gen_end":47478,"gen_start":46135,"node":232,"role":"declaration","source":0,"src_end":38139,"src_start":37042},{"artifact":1,"gen_end":47972,"gen_start":47478,"node":233,"role":"declaration","source":0,"src_end":38532,"src_start":38141},{"artifact":1,"gen_end":49276,"gen_start":47972,"node":234,"role":"declaration","source":0,"src_end":39596,"src_start":38534},{"artifact":1,"gen_end":49772,"gen_start":49276,"node":235,"role":"declaration","source":0,"src_end":39993,"src_start":39598},{"artifact":1,"gen_end":51630,"gen_start":49772,"node":236,"role":"declaration","source":0,"src_end":41577,"src_start":39995},{"artifact":1,"gen_end":52118,"gen_start":51630,"node":237,"role":"declaration","source":0,"src_end":41966,"src_start":41579},{"artifact":1,"gen_end":53077,"gen_start":52118,"node":238,"role":"declaration","source":0,"src_end":42693,"src_start":41968},{"artifact":1,"gen_end":53581,"gen_start":53077,"node":239,"role":"declaration","source":0,"src_end":43090,"src_start":42695},{"artifact":1,"gen_end":54827,"gen_start":53581,"node":240,"role":"declaration","source":0,"src_end":44094,"src_start":43092},{"artifact":1,"gen_end":55333,"gen_start":54827,"node":241,"role":"declaration","source":0,"src_end":44493,"src_start":44096},{"artifact":1,"gen_end":56579,"gen_start":55333,"node":242,"role":"declaration","source":0,"src_end":45497,"src_start":44495},{"artifact":1,"gen_end":57085,"gen_start":56579,"node":243,"role":"declaration","source":0,"src_end":45896,"src_start":45499},{"artifact":1,"gen_end":58376,"gen_start":57085,"node":244,"role":"declaration","source":0,"src_end":46957,"src_start":45898},{"artifact":1,"gen_end":58888,"gen_start":58376,"node":245,"role":"declaration","source":0,"src_end":47362,"src_start":46959},{"artifact":1,"gen_end":60227,"gen_start":58888,"node":246,"role":"declaration","source":0,"src_end":48455,"src_start":47364},{"artifact":1,"gen_end":60648,"gen_start":60227,"node":247,"role":"declaration","source":0,"src_end":48783,"src_start":48457},{"artifact":1,"gen_end":61436,"gen_start":60648,"node":248,"role":"declaration","source":0,"src_end":49359,"src_start":48785},{"artifact":1,"gen_end":61939,"gen_start":61436,"node":249,"role":"declaration","source":0,"src_end":49761,"src_start":49361},{"artifact":1,"gen_end":63270,"gen_start":61939,"node":250,"role":"declaration","source":0,"src_end":50846,"src_start":49763},{"artifact":1,"gen_end":63747,"gen_start":63270,"node":251,"role":"declaration","source":0,"src_end":51224,"src_start":50848},{"artifact":1,"gen_end":65087,"gen_start":63747,"node":252,"role":"declaration","source":0,"src_end":52308,"src_start":51226},{"artifact":1,"gen_end":65541,"gen_start":65087,"node":253,"role":"declaration","source":0,"src_end":52661,"src_start":52310},{"artifact":1,"gen_end":66875,"gen_start":65541,"node":254,"role":"declaration","source":0,"src_end":53765,"src_start":52663},{"artifact":1,"gen_end":67329,"gen_start":66875,"node":255,"role":"declaration","source":0,"src_end":54118,"src_start":53767},{"artifact":1,"gen_end":68513,"gen_start":67329,"node":256,"role":"declaration","source":0,"src_end":55054,"src_start":54120},{"artifact":1,"gen_end":69038,"gen_start":68513,"node":257,"role":"declaration","source":0,"src_end":55472,"src_start":55056},{"artifact":1,"gen_end":70342,"gen_start":69038,"node":258,"role":"declaration","source":0,"src_end":56536,"src_start":55474},{"artifact":1,"gen_end":70854,"gen_start":70342,"node":259,"role":"declaration","source":0,"src_end":56941,"src_start":56538},{"artifact":1,"gen_end":72218,"gen_start":70854,"node":260,"role":"declaration","source":0,"src_end":58083,"src_start":56943},{"artifact":1,"gen_end":72726,"gen_start":72218,"node":261,"role":"declaration","source":0,"src_end":58484,"src_start":58085},{"artifact":1,"gen_end":73916,"gen_start":72726,"node":262,"role":"declaration","source":0,"src_end":59438,"src_start":58486},{"artifact":1,"gen_end":74343,"gen_start":73916,"node":263,"role":"declaration","source":0,"src_end":59772,"src_start":59440},{"artifact":1,"gen_end":75607,"gen_start":74343,"node":264,"role":"declaration","source":0,"src_end":60786,"src_start":59774},{"artifact":1,"gen_end":76111,"gen_start":75607,"node":265,"role":"declaration","source":0,"src_end":61183,"src_start":60788},{"artifact":1,"gen_end":77322,"gen_start":76111,"node":266,"role":"declaration","source":0,"src_end":62128,"src_start":61185},{"artifact":1,"gen_end":77784,"gen_start":77322,"node":267,"role":"declaration","source":0,"src_end":62489,"src_start":62130},{"artifact":1,"gen_end":79678,"gen_start":77784,"node":268,"role":"declaration","source":0,"src_end":64105,"src_start":62491},{"artifact":1,"gen_end":80164,"gen_start":79678,"node":269,"role":"declaration","source":0,"src_end":64484,"src_start":64107},{"artifact":1,"gen_end":82007,"gen_start":80164,"node":270,"role":"declaration","source":0,"src_end":66051,"src_start":64486},{"artifact":1,"gen_end":82494,"gen_start":82007,"node":271,"role":"declaration","source":0,"src_end":66431,"src_start":66053},{"artifact":1,"gen_end":83781,"gen_start":82494,"node":272,"role":"declaration","source":0,"src_end":67476,"src_start":66433},{"artifact":1,"gen_end":84279,"gen_start":83781,"node":273,"role":"declaration","source":0,"src_end":67867,"src_start":67478},{"artifact":1,"gen_end":85564,"gen_start":84279,"node":274,"role":"declaration","source":0,"src_end":68910,"src_start":67869},{"artifact":1,"gen_end":86056,"gen_start":85564,"node":275,"role":"declaration","source":0,"src_end":69295,"src_start":68912},{"artifact":1,"gen_end":87343,"gen_start":86056,"node":276,"role":"declaration","source":0,"src_end":70354,"src_start":69297},{"artifact":1,"gen_end":87857,"gen_start":87343,"node":277,"role":"declaration","source":0,"src_end":70761,"src_start":70356},{"artifact":1,"gen_end":89112,"gen_start":87857,"node":278,"role":"declaration","source":0,"src_end":71762,"src_start":70763},{"artifact":1,"gen_end":89626,"gen_start":89112,"node":279,"role":"declaration","source":0,"src_end":72169,"src_start":71764},{"artifact":1,"gen_end":90665,"gen_start":89626,"node":280,"role":"declaration","source":0,"src_end":72976,"src_start":72171},{"artifact":1,"gen_end":91175,"gen_start":90665,"node":281,"role":"declaration","source":0,"src_end":73379,"src_start":72978},{"artifact":1,"gen_end":92295,"gen_start":91175,"node":282,"role":"declaration","source":0,"src_end":74225,"src_start":73381},{"artifact":1,"gen_end":92790,"gen_start":92295,"node":283,"role":"declaration","source":0,"src_end":74619,"src_start":74227},{"artifact":1,"gen_end":93914,"gen_start":92790,"node":284,"role":"declaration","source":0,"src_end":75469,"src_start":74621},{"artifact":1,"gen_end":94419,"gen_start":93914,"node":285,"role":"declaration","source":0,"src_end":75869,"src_start":75471},{"artifact":1,"gen_end":95540,"gen_start":94419,"node":286,"role":"declaration","source":0,"src_end":76716,"src_start":75871},{"artifact":1,"gen_end":96037,"gen_start":95540,"node":287,"role":"declaration","source":0,"src_end":77112,"src_start":76718},{"artifact":1,"gen_end":97329,"gen_start":96037,"node":288,"role":"declaration","source":0,"src_end":78162,"src_start":77114},{"artifact":1,"gen_end":97757,"gen_start":97329,"node":289,"role":"declaration","source":0,"src_end":78499,"src_start":78164},{"artifact":1,"gen_end":98955,"gen_start":97757,"node":290,"role":"declaration","source":0,"src_end":79443,"src_start":78501},{"artifact":1,"gen_end":99473,"gen_start":98955,"node":291,"role":"declaration","source":0,"src_end":79860,"src_start":79445},{"artifact":1,"gen_end":99856,"gen_start":99473,"node":292,"role":"declaration","source":0,"src_end":80166,"src_start":79862},{"artifact":1,"gen_end":101054,"gen_start":99856,"node":293,"role":"declaration","source":0,"src_end":81114,"src_start":80168},{"artifact":1,"gen_end":101560,"gen_start":101054,"node":294,"role":"declaration","source":0,"src_end":81519,"src_start":81116},{"artifact":1,"gen_end":101930,"gen_start":101560,"node":295,"role":"declaration","source":0,"src_end":81812,"src_start":81521},{"artifact":1,"gen_end":103174,"gen_start":101930,"node":296,"role":"declaration","source":0,"src_end":82794,"src_start":81814},{"artifact":1,"gen_end":103680,"gen_start":103174,"node":297,"role":"declaration","source":0,"src_end":83199,"src_start":82796},{"artifact":1,"gen_end":104051,"gen_start":103680,"node":298,"role":"declaration","source":0,"src_end":83493,"src_start":83201},{"artifact":1,"gen_end":105147,"gen_start":104051,"node":299,"role":"declaration","source":0,"src_end":84351,"src_start":83495},{"artifact":1,"gen_end":105608,"gen_start":105147,"node":300,"role":"declaration","source":0,"src_end":84711,"src_start":84353},{"artifact":1,"gen_end":105973,"gen_start":105608,"node":301,"role":"declaration","source":0,"src_end":84999,"src_start":84713},{"artifact":1,"gen_end":106983,"gen_start":105973,"node":302,"role":"declaration","source":0,"src_end":85787,"src_start":85001},{"artifact":1,"gen_end":107489,"gen_start":106983,"node":303,"role":"declaration","source":0,"src_end":86192,"src_start":85789},{"artifact":1,"gen_end":108490,"gen_start":107489,"node":304,"role":"declaration","source":0,"src_end":86971,"src_start":86194},{"artifact":1,"gen_end":108947,"gen_start":108490,"node":305,"role":"declaration","source":0,"src_end":87331,"src_start":86973},{"artifact":1,"gen_end":110146,"gen_start":108947,"node":306,"role":"declaration","source":0,"src_end":88276,"src_start":87333},{"artifact":1,"gen_end":110611,"gen_start":110146,"node":307,"role":"declaration","source":0,"src_end":88640,"src_start":88278},{"artifact":1,"gen_end":110981,"gen_start":110611,"node":308,"role":"declaration","source":0,"src_end":88933,"src_start":88642},{"artifact":1,"gen_end":112193,"gen_start":110981,"node":309,"role":"declaration","source":0,"src_end":89891,"src_start":88935},{"artifact":1,"gen_end":112700,"gen_start":112193,"node":310,"role":"declaration","source":0,"src_end":90297,"src_start":89893},{"artifact":1,"gen_end":113072,"gen_start":112700,"node":311,"role":"declaration","source":0,"src_end":90592,"src_start":90299},{"artifact":1,"gen_end":114274,"gen_start":113072,"node":312,"role":"declaration","source":0,"src_end":91540,"src_start":90594},{"artifact":1,"gen_end":114734,"gen_start":114274,"node":313,"role":"declaration","source":0,"src_end":91899,"src_start":91542},{"artifact":1,"gen_end":115099,"gen_start":114734,"node":314,"role":"declaration","source":0,"src_end":92187,"src_start":91901},{"artifact":1,"gen_end":115801,"gen_start":115099,"node":315,"role":"declaration","source":0,"src_end":92691,"src_start":92189},{"artifact":1,"gen_end":116278,"gen_start":115801,"node":316,"role":"declaration","source":0,"src_end":93069,"src_start":92693},{"artifact":1,"gen_end":117080,"gen_start":116278,"node":317,"role":"declaration","source":0,"src_end":93661,"src_start":93071},{"artifact":1,"gen_end":117563,"gen_start":117080,"node":318,"role":"declaration","source":0,"src_end":94045,"src_start":93663},{"artifact":1,"gen_end":117934,"gen_start":117563,"node":319,"role":"declaration","source":0,"src_end":94339,"src_start":94047},{"artifact":1,"gen_end":119223,"gen_start":117934,"node":320,"role":"declaration","source":0,"src_end":95386,"src_start":94341},{"artifact":1,"gen_end":119640,"gen_start":119223,"node":321,"role":"declaration","source":0,"src_end":95712,"src_start":95388},{"artifact":1,"gen_end":120929,"gen_start":119640,"node":322,"role":"declaration","source":0,"src_end":96761,"src_start":95714},{"artifact":1,"gen_end":121357,"gen_start":120929,"node":323,"role":"declaration","source":0,"src_end":97098,"src_start":96763},{"artifact":1,"gen_end":122403,"gen_start":121357,"node":324,"role":"declaration","source":0,"src_end":97914,"src_start":97100},{"artifact":1,"gen_end":122843,"gen_start":122403,"node":325,"role":"declaration","source":0,"src_end":98263,"src_start":97916},{"artifact":1,"gen_end":124132,"gen_start":122843,"node":326,"role":"declaration","source":0,"src_end":99310,"src_start":98265},{"artifact":1,"gen_end":124548,"gen_start":124132,"node":327,"role":"declaration","source":0,"src_end":99635,"src_start":99312},{"artifact":1,"gen_end":125839,"gen_start":124548,"node":328,"role":"declaration","source":0,"src_end":100684,"src_start":99637},{"artifact":1,"gen_end":126264,"gen_start":125839,"node":329,"role":"declaration","source":0,"src_end":101018,"src_start":100686},{"artifact":1,"gen_end":126608,"gen_start":126264,"node":330,"role":"declaration","source":0,"src_end":101279,"src_start":101020},{"artifact":1,"gen_end":126954,"gen_start":126608,"node":331,"role":"declaration","source":0,"src_end":101542,"src_start":101281},{"artifact":1,"gen_end":127299,"gen_start":126954,"node":332,"role":"declaration","source":0,"src_end":101804,"src_start":101544},{"artifact":1,"gen_end":127645,"gen_start":127299,"node":333,"role":"declaration","source":0,"src_end":102067,"src_start":101806},{"artifact":1,"gen_end":127989,"gen_start":127645,"node":334,"role":"declaration","source":0,"src_end":102328,"src_start":102069},{"artifact":1,"gen_end":128334,"gen_start":127989,"node":335,"role":"declaration","source":0,"src_end":102590,"src_start":102330},{"artifact":1,"gen_end":128678,"gen_start":128334,"node":336,"role":"declaration","source":0,"src_end":102851,"src_start":102592},{"artifact":1,"gen_end":129024,"gen_start":128678,"node":337,"role":"declaration","source":0,"src_end":103114,"src_start":102853},{"artifact":1,"gen_end":129368,"gen_start":129024,"node":338,"role":"declaration","source":0,"src_end":103375,"src_start":103116},{"artifact":1,"gen_end":129713,"gen_start":129368,"node":339,"role":"declaration","source":0,"src_end":103637,"src_start":103377},{"artifact":1,"gen_end":130043,"gen_start":129713,"node":340,"role":"declaration","source":0,"src_end":103884,"src_start":103639},{"artifact":1,"gen_end":130375,"gen_start":130043,"node":341,"role":"declaration","source":0,"src_end":104133,"src_start":103886},{"artifact":1,"gen_end":130705,"gen_start":130375,"node":342,"role":"declaration","source":0,"src_end":104380,"src_start":104135},{"artifact":1,"gen_end":131036,"gen_start":130705,"node":343,"role":"declaration","source":0,"src_end":104628,"src_start":104382},{"artifact":1,"gen_end":131358,"gen_start":131036,"node":344,"role":"declaration","source":0,"src_end":104867,"src_start":104630},{"artifact":1,"gen_end":131682,"gen_start":131358,"node":345,"role":"declaration","source":0,"src_end":105108,"src_start":104869},{"artifact":1,"gen_end":132004,"gen_start":131682,"node":346,"role":"declaration","source":0,"src_end":105347,"src_start":105110},{"artifact":1,"gen_end":132327,"gen_start":132004,"node":347,"role":"declaration","source":0,"src_end":105587,"src_start":105349},{"artifact":1,"gen_end":132342,"gen_start":132327,"node":174,"role":"declaration","source":0,"src_end":105623,"src_start":0}],"module":"GnafCertificates","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-latex-module"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-declaration"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/GnafCertificates.lex.tex","sha256":"498dafa5093f56f0a05bbddb58875aebc0769325386f2ca611f3a101d9368f64"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GnafCertificates.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GnafCertificates.tex"}],"mappings":[{"artifact":0,"gen_end":414,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":0,"gen_end":1247,"gen_start":414,"node":1,"role":"declaration","source":0,"src_end":1053,"src_start":261},{"artifact":0,"gen_end":1546,"gen_start":1247,"node":2,"role":"declaration","source":0,"src_end":1401,"src_start":1055},{"artifact":0,"gen_end":2308,"gen_start":1546,"node":3,"role":"declaration","source":0,"src_end":2136,"src_start":1403},{"artifact":0,"gen_end":2653,"gen_start":2308,"node":4,"role":"declaration","source":0,"src_end":2528,"src_start":2138},{"artifact":0,"gen_end":3488,"gen_start":2653,"node":5,"role":"declaration","source":0,"src_end":3324,"src_start":2530},{"artifact":0,"gen_end":3829,"gen_start":3488,"node":6,"role":"declaration","source":0,"src_end":3714,"src_start":3326},{"artifact":0,"gen_end":4664,"gen_start":3829,"node":7,"role":"declaration","source":0,"src_end":4510,"src_start":3716},{"artifact":0,"gen_end":5001,"gen_start":4664,"node":8,"role":"declaration","source":0,"src_end":4898,"src_start":4512},{"artifact":0,"gen_end":6126,"gen_start":5001,"node":9,"role":"declaration","source":0,"src_end":5944,"src_start":4900},{"artifact":0,"gen_end":6465,"gen_start":6126,"node":10,"role":"declaration","source":0,"src_end":6332,"src_start":5946},{"artifact":0,"gen_end":6673,"gen_start":6465,"node":11,"role":"declaration","source":0,"src_end":6613,"src_start":6334},{"artifact":0,"gen_end":7508,"gen_start":6673,"node":12,"role":"declaration","source":0,"src_end":7409,"src_start":6615},{"artifact":0,"gen_end":7856,"gen_start":7508,"node":13,"role":"declaration","source":0,"src_end":7802,"src_start":7411},{"artifact":0,"gen_end":8693,"gen_start":7856,"node":14,"role":"declaration","source":0,"src_end":8598,"src_start":7804},{"artifact":0,"gen_end":9028,"gen_start":8693,"node":15,"role":"declaration","source":0,"src_end":8982,"src_start":8600},{"artifact":0,"gen_end":9962,"gen_start":9028,"node":16,"role":"declaration","source":0,"src_end":9869,"src_start":8984},{"artifact":0,"gen_end":10306,"gen_start":9962,"node":17,"role":"declaration","source":0,"src_end":10262,"src_start":9871},{"artifact":0,"gen_end":11139,"gen_start":10306,"node":18,"role":"declaration","source":0,"src_end":11056,"src_start":10264},{"artifact":0,"gen_end":11474,"gen_start":11139,"node":19,"role":"declaration","source":0,"src_end":11440,"src_start":11058},{"artifact":0,"gen_end":12603,"gen_start":11474,"node":20,"role":"declaration","source":0,"src_end":12487,"src_start":11442},{"artifact":0,"gen_end":12869,"gen_start":12603,"node":21,"role":"declaration","source":0,"src_end":12812,"src_start":12489},{"artifact":0,"gen_end":13673,"gen_start":12869,"node":22,"role":"declaration","source":0,"src_end":13560,"src_start":12814},{"artifact":0,"gen_end":14036,"gen_start":13673,"node":23,"role":"declaration","source":0,"src_end":13972,"src_start":13562},{"artifact":0,"gen_end":14868,"gen_start":14036,"node":24,"role":"declaration","source":0,"src_end":14740,"src_start":13974},{"artifact":0,"gen_end":15218,"gen_start":14868,"node":25,"role":"declaration","source":0,"src_end":15141,"src_start":14742},{"artifact":0,"gen_end":16036,"gen_start":15218,"node":26,"role":"declaration","source":0,"src_end":15891,"src_start":15143},{"artifact":0,"gen_end":16393,"gen_start":16036,"node":27,"role":"declaration","source":0,"src_end":16297,"src_start":15893},{"artifact":0,"gen_end":17223,"gen_start":16393,"node":28,"role":"declaration","source":0,"src_end":17059,"src_start":16299},{"artifact":0,"gen_end":17575,"gen_start":17223,"node":29,"role":"declaration","source":0,"src_end":17460,"src_start":17061},{"artifact":0,"gen_end":18403,"gen_start":17575,"node":30,"role":"declaration","source":0,"src_end":18222,"src_start":17462},{"artifact":0,"gen_end":18759,"gen_start":18403,"node":31,"role":"declaration","source":0,"src_end":18629,"src_start":18224},{"artifact":0,"gen_end":19562,"gen_start":18759,"node":32,"role":"declaration","source":0,"src_end":19372,"src_start":18631},{"artifact":0,"gen_end":19920,"gen_start":19562,"node":33,"role":"declaration","source":0,"src_end":19779,"src_start":19374},{"artifact":0,"gen_end":21009,"gen_start":19920,"node":34,"role":"declaration","source":0,"src_end":20792,"src_start":19781},{"artifact":0,"gen_end":21328,"gen_start":21009,"node":35,"role":"declaration","source":0,"src_end":21164,"src_start":20794},{"artifact":0,"gen_end":22148,"gen_start":21328,"node":36,"role":"declaration","source":0,"src_end":21916,"src_start":21166},{"artifact":0,"gen_end":22502,"gen_start":22148,"node":37,"role":"declaration","source":0,"src_end":22319,"src_start":21918},{"artifact":0,"gen_end":24146,"gen_start":22502,"node":38,"role":"declaration","source":0,"src_end":23855,"src_start":22321},{"artifact":0,"gen_end":24442,"gen_start":24146,"node":39,"role":"declaration","source":0,"src_end":24206,"src_start":23857},{"artifact":0,"gen_end":26086,"gen_start":24442,"node":40,"role":"declaration","source":0,"src_end":25740,"src_start":24208},{"artifact":0,"gen_end":26429,"gen_start":26086,"node":41,"role":"declaration","source":0,"src_end":26132,"src_start":25742},{"artifact":0,"gen_end":27320,"gen_start":26429,"node":42,"role":"declaration","source":0,"src_end":26955,"src_start":26134},{"artifact":0,"gen_end":27681,"gen_start":27320,"node":43,"role":"declaration","source":0,"src_end":27365,"src_start":26957},{"artifact":0,"gen_end":28568,"gen_start":27681,"node":44,"role":"declaration","source":0,"src_end":28182,"src_start":27367},{"artifact":0,"gen_end":28935,"gen_start":28568,"node":45,"role":"declaration","source":0,"src_end":28598,"src_start":28184},{"artifact":0,"gen_end":29752,"gen_start":28935,"node":46,"role":"declaration","source":0,"src_end":29349,"src_start":28600},{"artifact":0,"gen_end":30060,"gen_start":29752,"node":47,"role":"declaration","source":0,"src_end":29712,"src_start":29351},{"artifact":0,"gen_end":31192,"gen_start":30060,"node":48,"role":"declaration","source":0,"src_end":30762,"src_start":29714},{"artifact":0,"gen_end":31491,"gen_start":31192,"node":49,"role":"declaration","source":0,"src_end":31110,"src_start":30764},{"artifact":0,"gen_end":32368,"gen_start":31491,"node":50,"role":"declaration","source":0,"src_end":31915,"src_start":31112},{"artifact":0,"gen_end":32667,"gen_start":32368,"node":51,"role":"declaration","source":0,"src_end":32263,"src_start":31917},{"artifact":0,"gen_end":33801,"gen_start":32667,"node":52,"role":"declaration","source":0,"src_end":33315,"src_start":32265},{"artifact":0,"gen_end":34110,"gen_start":33801,"node":53,"role":"declaration","source":0,"src_end":33673,"src_start":33317},{"artifact":0,"gen_end":35799,"gen_start":34110,"node":54,"role":"declaration","source":0,"src_end":35248,"src_start":33675},{"artifact":0,"gen_end":36090,"gen_start":35799,"node":55,"role":"declaration","source":0,"src_end":35590,"src_start":35250},{"artifact":0,"gen_end":37229,"gen_start":36090,"node":56,"role":"declaration","source":0,"src_end":36649,"src_start":35592},{"artifact":0,"gen_end":37569,"gen_start":37229,"node":57,"role":"declaration","source":0,"src_end":37040,"src_start":36651},{"artifact":0,"gen_end":38752,"gen_start":37569,"node":58,"role":"declaration","source":0,"src_end":38139,"src_start":37042},{"artifact":0,"gen_end":39096,"gen_start":38752,"node":59,"role":"declaration","source":0,"src_end":38532,"src_start":38141},{"artifact":0,"gen_end":40240,"gen_start":39096,"node":60,"role":"declaration","source":0,"src_end":39596,"src_start":38534},{"artifact":0,"gen_end":40586,"gen_start":40240,"node":61,"role":"declaration","source":0,"src_end":39993,"src_start":39598},{"artifact":0,"gen_end":42284,"gen_start":40586,"node":62,"role":"declaration","source":0,"src_end":41577,"src_start":39995},{"artifact":0,"gen_end":42622,"gen_start":42284,"node":63,"role":"declaration","source":0,"src_end":41966,"src_start":41579},{"artifact":0,"gen_end":43421,"gen_start":42622,"node":64,"role":"declaration","source":0,"src_end":42693,"src_start":41968},{"artifact":0,"gen_end":43775,"gen_start":43421,"node":65,"role":"declaration","source":0,"src_end":43090,"src_start":42695},{"artifact":0,"gen_end":44861,"gen_start":43775,"node":66,"role":"declaration","source":0,"src_end":44094,"src_start":43092},{"artifact":0,"gen_end":45217,"gen_start":44861,"node":67,"role":"declaration","source":0,"src_end":44493,"src_start":44096},{"artifact":0,"gen_end":46303,"gen_start":45217,"node":68,"role":"declaration","source":0,"src_end":45497,"src_start":44495},{"artifact":0,"gen_end":46659,"gen_start":46303,"node":69,"role":"declaration","source":0,"src_end":45896,"src_start":45499},{"artifact":0,"gen_end":47790,"gen_start":46659,"node":70,"role":"declaration","source":0,"src_end":46957,"src_start":45898},{"artifact":0,"gen_end":48152,"gen_start":47790,"node":71,"role":"declaration","source":0,"src_end":47362,"src_start":46959},{"artifact":0,"gen_end":49331,"gen_start":48152,"node":72,"role":"declaration","source":0,"src_end":48455,"src_start":47364},{"artifact":0,"gen_end":49602,"gen_start":49331,"node":73,"role":"declaration","source":0,"src_end":48783,"src_start":48457},{"artifact":0,"gen_end":50230,"gen_start":49602,"node":74,"role":"declaration","source":0,"src_end":49359,"src_start":48785},{"artifact":0,"gen_end":50583,"gen_start":50230,"node":75,"role":"declaration","source":0,"src_end":49761,"src_start":49361},{"artifact":0,"gen_end":51754,"gen_start":50583,"node":76,"role":"declaration","source":0,"src_end":50846,"src_start":49763},{"artifact":0,"gen_end":52081,"gen_start":51754,"node":77,"role":"declaration","source":0,"src_end":51224,"src_start":50848},{"artifact":0,"gen_end":53261,"gen_start":52081,"node":78,"role":"declaration","source":0,"src_end":52308,"src_start":51226},{"artifact":0,"gen_end":53565,"gen_start":53261,"node":79,"role":"declaration","source":0,"src_end":52661,"src_start":52310},{"artifact":0,"gen_end":54739,"gen_start":53565,"node":80,"role":"declaration","source":0,"src_end":53765,"src_start":52663},{"artifact":0,"gen_end":55043,"gen_start":54739,"node":81,"role":"declaration","source":0,"src_end":54118,"src_start":53767},{"artifact":0,"gen_end":56067,"gen_start":55043,"node":82,"role":"declaration","source":0,"src_end":55054,"src_start":54120},{"artifact":0,"gen_end":56442,"gen_start":56067,"node":83,"role":"declaration","source":0,"src_end":55472,"src_start":55056},{"artifact":0,"gen_end":57586,"gen_start":56442,"node":84,"role":"declaration","source":0,"src_end":56536,"src_start":55474},{"artifact":0,"gen_end":57948,"gen_start":57586,"node":85,"role":"declaration","source":0,"src_end":56941,"src_start":56538},{"artifact":0,"gen_end":59152,"gen_start":57948,"node":86,"role":"declaration","source":0,"src_end":58083,"src_start":56943},{"artifact":0,"gen_end":59510,"gen_start":59152,"node":87,"role":"declaration","source":0,"src_end":58484,"src_start":58085},{"artifact":0,"gen_end":60540,"gen_start":59510,"node":88,"role":"declaration","source":0,"src_end":59438,"src_start":58486},{"artifact":0,"gen_end":60817,"gen_start":60540,"node":89,"role":"declaration","source":0,"src_end":59772,"src_start":59440},{"artifact":0,"gen_end":61921,"gen_start":60817,"node":90,"role":"declaration","source":0,"src_end":60786,"src_start":59774},{"artifact":0,"gen_end":62275,"gen_start":61921,"node":91,"role":"declaration","source":0,"src_end":61183,"src_start":60788},{"artifact":0,"gen_end":63326,"gen_start":62275,"node":92,"role":"declaration","source":0,"src_end":62128,"src_start":61185},{"artifact":0,"gen_end":63638,"gen_start":63326,"node":93,"role":"declaration","source":0,"src_end":62489,"src_start":62130},{"artifact":0,"gen_end":65372,"gen_start":63638,"node":94,"role":"declaration","source":0,"src_end":64105,"src_start":62491},{"artifact":0,"gen_end":65708,"gen_start":65372,"node":95,"role":"declaration","source":0,"src_end":64484,"src_start":64107},{"artifact":0,"gen_end":67391,"gen_start":65708,"node":96,"role":"declaration","source":0,"src_end":66051,"src_start":64486},{"artifact":0,"gen_end":67728,"gen_start":67391,"node":97,"role":"declaration","source":0,"src_end":66431,"src_start":66053},{"artifact":0,"gen_end":68855,"gen_start":67728,"node":98,"role":"declaration","source":0,"src_end":67476,"src_start":66433},{"artifact":0,"gen_end":69203,"gen_start":68855,"node":99,"role":"declaration","source":0,"src_end":67867,"src_start":67478},{"artifact":0,"gen_end":70328,"gen_start":69203,"node":100,"role":"declaration","source":0,"src_end":68910,"src_start":67869},{"artifact":0,"gen_end":70670,"gen_start":70328,"node":101,"role":"declaration","source":0,"src_end":69295,"src_start":68912},{"artifact":0,"gen_end":71797,"gen_start":70670,"node":102,"role":"declaration","source":0,"src_end":70354,"src_start":69297},{"artifact":0,"gen_end":72161,"gen_start":71797,"node":103,"role":"declaration","source":0,"src_end":70761,"src_start":70356},{"artifact":0,"gen_end":73256,"gen_start":72161,"node":104,"role":"declaration","source":0,"src_end":71762,"src_start":70763},{"artifact":0,"gen_end":73620,"gen_start":73256,"node":105,"role":"declaration","source":0,"src_end":72169,"src_start":71764},{"artifact":0,"gen_end":74499,"gen_start":73620,"node":106,"role":"declaration","source":0,"src_end":72976,"src_start":72171},{"artifact":0,"gen_end":74859,"gen_start":74499,"node":107,"role":"declaration","source":0,"src_end":73379,"src_start":72978},{"artifact":0,"gen_end":75819,"gen_start":74859,"node":108,"role":"declaration","source":0,"src_end":74225,"src_start":73381},{"artifact":0,"gen_end":76164,"gen_start":75819,"node":109,"role":"declaration","source":0,"src_end":74619,"src_start":74227},{"artifact":0,"gen_end":77128,"gen_start":76164,"node":110,"role":"declaration","source":0,"src_end":75469,"src_start":74621},{"artifact":0,"gen_end":77483,"gen_start":77128,"node":111,"role":"declaration","source":0,"src_end":75869,"src_start":75471},{"artifact":0,"gen_end":78444,"gen_start":77483,"node":112,"role":"declaration","source":0,"src_end":76716,"src_start":75871},{"artifact":0,"gen_end":78791,"gen_start":78444,"node":113,"role":"declaration","source":0,"src_end":77112,"src_start":76718},{"artifact":0,"gen_end":79923,"gen_start":78791,"node":114,"role":"declaration","source":0,"src_end":78162,"src_start":77114},{"artifact":0,"gen_end":80201,"gen_start":79923,"node":115,"role":"declaration","source":0,"src_end":78499,"src_start":78164},{"artifact":0,"gen_end":81239,"gen_start":80201,"node":116,"role":"declaration","source":0,"src_end":79443,"src_start":78501},{"artifact":0,"gen_end":81607,"gen_start":81239,"node":117,"role":"declaration","source":0,"src_end":79860,"src_start":79445},{"artifact":0,"gen_end":81840,"gen_start":81607,"node":118,"role":"declaration","source":0,"src_end":80166,"src_start":79862},{"artifact":0,"gen_end":82878,"gen_start":81840,"node":119,"role":"declaration","source":0,"src_end":81114,"src_start":80168},{"artifact":0,"gen_end":83234,"gen_start":82878,"node":120,"role":"declaration","source":0,"src_end":81519,"src_start":81116},{"artifact":0,"gen_end":83454,"gen_start":83234,"node":121,"role":"declaration","source":0,"src_end":81812,"src_start":81521},{"artifact":0,"gen_end":84538,"gen_start":83454,"node":122,"role":"declaration","source":0,"src_end":82794,"src_start":81814},{"artifact":0,"gen_end":84894,"gen_start":84538,"node":123,"role":"declaration","source":0,"src_end":83199,"src_start":82796},{"artifact":0,"gen_end":85115,"gen_start":84894,"node":124,"role":"declaration","source":0,"src_end":83493,"src_start":83201},{"artifact":0,"gen_end":86051,"gen_start":85115,"node":125,"role":"declaration","source":0,"src_end":84351,"src_start":83495},{"artifact":0,"gen_end":86362,"gen_start":86051,"node":126,"role":"declaration","source":0,"src_end":84711,"src_start":84353},{"artifact":0,"gen_end":86577,"gen_start":86362,"node":127,"role":"declaration","source":0,"src_end":84999,"src_start":84713},{"artifact":0,"gen_end":87427,"gen_start":86577,"node":128,"role":"declaration","source":0,"src_end":85787,"src_start":85001},{"artifact":0,"gen_end":87783,"gen_start":87427,"node":129,"role":"declaration","source":0,"src_end":86192,"src_start":85789},{"artifact":0,"gen_end":88624,"gen_start":87783,"node":130,"role":"declaration","source":0,"src_end":86971,"src_start":86194},{"artifact":0,"gen_end":88931,"gen_start":88624,"node":131,"role":"declaration","source":0,"src_end":87331,"src_start":86973},{"artifact":0,"gen_end":89970,"gen_start":88931,"node":132,"role":"declaration","source":0,"src_end":88276,"src_start":87333},{"artifact":0,"gen_end":90285,"gen_start":89970,"node":133,"role":"declaration","source":0,"src_end":88640,"src_start":88278},{"artifact":0,"gen_end":90505,"gen_start":90285,"node":134,"role":"declaration","source":0,"src_end":88933,"src_start":88642},{"artifact":0,"gen_end":91557,"gen_start":90505,"node":135,"role":"declaration","source":0,"src_end":89891,"src_start":88935},{"artifact":0,"gen_end":91914,"gen_start":91557,"node":136,"role":"declaration","source":0,"src_end":90297,"src_start":89893},{"artifact":0,"gen_end":92136,"gen_start":91914,"node":137,"role":"declaration","source":0,"src_end":90592,"src_start":90299},{"artifact":0,"gen_end":93178,"gen_start":92136,"node":138,"role":"declaration","source":0,"src_end":91540,"src_start":90594},{"artifact":0,"gen_end":93488,"gen_start":93178,"node":139,"role":"declaration","source":0,"src_end":91899,"src_start":91542},{"artifact":0,"gen_end":93703,"gen_start":93488,"node":140,"role":"declaration","source":0,"src_end":92187,"src_start":91901},{"artifact":0,"gen_end":94245,"gen_start":93703,"node":141,"role":"declaration","source":0,"src_end":92691,"src_start":92189},{"artifact":0,"gen_end":94572,"gen_start":94245,"node":142,"role":"declaration","source":0,"src_end":93069,"src_start":92693},{"artifact":0,"gen_end":95214,"gen_start":94572,"node":143,"role":"declaration","source":0,"src_end":93661,"src_start":93071},{"artifact":0,"gen_end":95547,"gen_start":95214,"node":144,"role":"declaration","source":0,"src_end":94045,"src_start":93663},{"artifact":0,"gen_end":95768,"gen_start":95547,"node":145,"role":"declaration","source":0,"src_end":94339,"src_start":94047},{"artifact":0,"gen_end":96897,"gen_start":95768,"node":146,"role":"declaration","source":0,"src_end":95386,"src_start":94341},{"artifact":0,"gen_end":97164,"gen_start":96897,"node":147,"role":"declaration","source":0,"src_end":95712,"src_start":95388},{"artifact":0,"gen_end":98293,"gen_start":97164,"node":148,"role":"declaration","source":0,"src_end":96761,"src_start":95714},{"artifact":0,"gen_end":98571,"gen_start":98293,"node":149,"role":"declaration","source":0,"src_end":97098,"src_start":96763},{"artifact":0,"gen_end":99457,"gen_start":98571,"node":150,"role":"declaration","source":0,"src_end":97914,"src_start":97100},{"artifact":0,"gen_end":99747,"gen_start":99457,"node":151,"role":"declaration","source":0,"src_end":98263,"src_start":97916},{"artifact":0,"gen_end":100876,"gen_start":99747,"node":152,"role":"declaration","source":0,"src_end":99310,"src_start":98265},{"artifact":0,"gen_end":101142,"gen_start":100876,"node":153,"role":"declaration","source":0,"src_end":99635,"src_start":99312},{"artifact":0,"gen_end":102273,"gen_start":101142,"node":154,"role":"declaration","source":0,"src_end":100684,"src_start":99637},{"artifact":0,"gen_end":102548,"gen_start":102273,"node":155,"role":"declaration","source":0,"src_end":101018,"src_start":100686},{"artifact":0,"gen_end":102742,"gen_start":102548,"node":156,"role":"declaration","source":0,"src_end":101279,"src_start":101020},{"artifact":0,"gen_end":102938,"gen_start":102742,"node":157,"role":"declaration","source":0,"src_end":101542,"src_start":101281},{"artifact":0,"gen_end":103133,"gen_start":102938,"node":158,"role":"declaration","source":0,"src_end":101804,"src_start":101544},{"artifact":0,"gen_end":103329,"gen_start":103133,"node":159,"role":"declaration","source":0,"src_end":102067,"src_start":101806},{"artifact":0,"gen_end":103523,"gen_start":103329,"node":160,"role":"declaration","source":0,"src_end":102328,"src_start":102069},{"artifact":0,"gen_end":103718,"gen_start":103523,"node":161,"role":"declaration","source":0,"src_end":102590,"src_start":102330},{"artifact":0,"gen_end":103912,"gen_start":103718,"node":162,"role":"declaration","source":0,"src_end":102851,"src_start":102592},{"artifact":0,"gen_end":104108,"gen_start":103912,"node":163,"role":"declaration","source":0,"src_end":103114,"src_start":102853},{"artifact":0,"gen_end":104302,"gen_start":104108,"node":164,"role":"declaration","source":0,"src_end":103375,"src_start":103116},{"artifact":0,"gen_end":104497,"gen_start":104302,"node":165,"role":"declaration","source":0,"src_end":103637,"src_start":103377},{"artifact":0,"gen_end":104677,"gen_start":104497,"node":166,"role":"declaration","source":0,"src_end":103884,"src_start":103639},{"artifact":0,"gen_end":104859,"gen_start":104677,"node":167,"role":"declaration","source":0,"src_end":104133,"src_start":103886},{"artifact":0,"gen_end":105039,"gen_start":104859,"node":168,"role":"declaration","source":0,"src_end":104380,"src_start":104135},{"artifact":0,"gen_end":105220,"gen_start":105039,"node":169,"role":"declaration","source":0,"src_end":104628,"src_start":104382},{"artifact":0,"gen_end":105392,"gen_start":105220,"node":170,"role":"declaration","source":0,"src_end":104867,"src_start":104630},{"artifact":0,"gen_end":105566,"gen_start":105392,"node":171,"role":"declaration","source":0,"src_end":105108,"src_start":104869},{"artifact":0,"gen_end":105738,"gen_start":105566,"node":172,"role":"declaration","source":0,"src_end":105347,"src_start":105110},{"artifact":0,"gen_end":105911,"gen_start":105738,"node":173,"role":"declaration","source":0,"src_end":105587,"src_start":105349},{"artifact":0,"gen_end":105947,"gen_start":105911,"node":0,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":174,"role":"declaration","source":0,"src_end":105623,"src_start":0},{"artifact":1,"gen_end":1129,"gen_start":134,"node":175,"role":"declaration","source":0,"src_end":1053,"src_start":261},{"artifact":1,"gen_end":1578,"gen_start":1129,"node":176,"role":"declaration","source":0,"src_end":1401,"src_start":1055},{"artifact":1,"gen_end":2500,"gen_start":1578,"node":177,"role":"declaration","source":0,"src_end":2136,"src_start":1403},{"artifact":1,"gen_end":2995,"gen_start":2500,"node":178,"role":"declaration","source":0,"src_end":2528,"src_start":2138},{"artifact":1,"gen_end":3992,"gen_start":2995,"node":179,"role":"declaration","source":0,"src_end":3324,"src_start":2530},{"artifact":1,"gen_end":4483,"gen_start":3992,"node":180,"role":"declaration","source":0,"src_end":3714,"src_start":3326},{"artifact":1,"gen_end":5480,"gen_start":4483,"node":181,"role":"declaration","source":0,"src_end":4510,"src_start":3716},{"artifact":1,"gen_end":5967,"gen_start":5480,"node":182,"role":"declaration","source":0,"src_end":4898,"src_start":4512},{"artifact":1,"gen_end":7254,"gen_start":5967,"node":183,"role":"declaration","source":0,"src_end":5944,"src_start":4900},{"artifact":1,"gen_end":7743,"gen_start":7254,"node":184,"role":"declaration","source":0,"src_end":6332,"src_start":5946},{"artifact":1,"gen_end":8101,"gen_start":7743,"node":185,"role":"declaration","source":0,"src_end":6613,"src_start":6334},{"artifact":1,"gen_end":9098,"gen_start":8101,"node":186,"role":"declaration","source":0,"src_end":7409,"src_start":6615},{"artifact":1,"gen_end":9596,"gen_start":9098,"node":187,"role":"declaration","source":0,"src_end":7802,"src_start":7411},{"artifact":1,"gen_end":10595,"gen_start":9596,"node":188,"role":"declaration","source":0,"src_end":8598,"src_start":7804},{"artifact":1,"gen_end":11080,"gen_start":10595,"node":189,"role":"declaration","source":0,"src_end":8982,"src_start":8600},{"artifact":1,"gen_end":12176,"gen_start":11080,"node":190,"role":"declaration","source":0,"src_end":9869,"src_start":8984},{"artifact":1,"gen_end":12670,"gen_start":12176,"node":191,"role":"declaration","source":0,"src_end":10262,"src_start":9871},{"artifact":1,"gen_end":13665,"gen_start":12670,"node":192,"role":"declaration","source":0,"src_end":11056,"src_start":10264},{"artifact":1,"gen_end":14150,"gen_start":13665,"node":193,"role":"declaration","source":0,"src_end":11440,"src_start":11058},{"artifact":1,"gen_end":15439,"gen_start":14150,"node":194,"role":"declaration","source":0,"src_end":12487,"src_start":11442},{"artifact":1,"gen_end":15855,"gen_start":15439,"node":195,"role":"declaration","source":0,"src_end":12812,"src_start":12489},{"artifact":1,"gen_end":16819,"gen_start":15855,"node":196,"role":"declaration","source":0,"src_end":13560,"src_start":12814},{"artifact":1,"gen_end":17332,"gen_start":16819,"node":197,"role":"declaration","source":0,"src_end":13972,"src_start":13562},{"artifact":1,"gen_end":18324,"gen_start":17332,"node":198,"role":"declaration","source":0,"src_end":14740,"src_start":13974},{"artifact":1,"gen_end":18824,"gen_start":18324,"node":199,"role":"declaration","source":0,"src_end":15141,"src_start":14742},{"artifact":1,"gen_end":19802,"gen_start":18824,"node":200,"role":"declaration","source":0,"src_end":15891,"src_start":15143},{"artifact":1,"gen_end":20309,"gen_start":19802,"node":201,"role":"declaration","source":0,"src_end":16297,"src_start":15893},{"artifact":1,"gen_end":21299,"gen_start":20309,"node":202,"role":"declaration","source":0,"src_end":17059,"src_start":16299},{"artifact":1,"gen_end":21801,"gen_start":21299,"node":203,"role":"declaration","source":0,"src_end":17460,"src_start":17061},{"artifact":1,"gen_end":22789,"gen_start":21801,"node":204,"role":"declaration","source":0,"src_end":18222,"src_start":17462},{"artifact":1,"gen_end":23295,"gen_start":22789,"node":205,"role":"declaration","source":0,"src_end":18629,"src_start":18224},{"artifact":1,"gen_end":24258,"gen_start":23295,"node":206,"role":"declaration","source":0,"src_end":19372,"src_start":18631},{"artifact":1,"gen_end":24766,"gen_start":24258,"node":207,"role":"declaration","source":0,"src_end":19779,"src_start":19374},{"artifact":1,"gen_end":26015,"gen_start":24766,"node":208,"role":"declaration","source":0,"src_end":20792,"src_start":19781},{"artifact":1,"gen_end":26484,"gen_start":26015,"node":209,"role":"declaration","source":0,"src_end":21164,"src_start":20794},{"artifact":1,"gen_end":27464,"gen_start":26484,"node":210,"role":"declaration","source":0,"src_end":21916,"src_start":21166},{"artifact":1,"gen_end":27968,"gen_start":27464,"node":211,"role":"declaration","source":0,"src_end":22319,"src_start":21918},{"artifact":1,"gen_end":29772,"gen_start":27968,"node":212,"role":"declaration","source":0,"src_end":23855,"src_start":22321},{"artifact":1,"gen_end":30218,"gen_start":29772,"node":213,"role":"declaration","source":0,"src_end":24206,"src_start":23857},{"artifact":1,"gen_end":32022,"gen_start":30218,"node":214,"role":"declaration","source":0,"src_end":25740,"src_start":24208},{"artifact":1,"gen_end":32515,"gen_start":32022,"node":215,"role":"declaration","source":0,"src_end":26132,"src_start":25742},{"artifact":1,"gen_end":33566,"gen_start":32515,"node":216,"role":"declaration","source":0,"src_end":26955,"src_start":26134},{"artifact":1,"gen_end":34077,"gen_start":33566,"node":217,"role":"declaration","source":0,"src_end":27365,"src_start":26957},{"artifact":1,"gen_end":35124,"gen_start":34077,"node":218,"role":"declaration","source":0,"src_end":28182,"src_start":27367},{"artifact":1,"gen_end":35641,"gen_start":35124,"node":219,"role":"declaration","source":0,"src_end":28598,"src_start":28184},{"artifact":1,"gen_end":36618,"gen_start":35641,"node":220,"role":"declaration","source":0,"src_end":29349,"src_start":28600},{"artifact":1,"gen_end":37076,"gen_start":36618,"node":221,"role":"declaration","source":0,"src_end":29712,"src_start":29351},{"artifact":1,"gen_end":38368,"gen_start":37076,"node":222,"role":"declaration","source":0,"src_end":30762,"src_start":29714},{"artifact":1,"gen_end":38817,"gen_start":38368,"node":223,"role":"declaration","source":0,"src_end":31110,"src_start":30764},{"artifact":1,"gen_end":39854,"gen_start":38817,"node":224,"role":"declaration","source":0,"src_end":31915,"src_start":31112},{"artifact":1,"gen_end":40303,"gen_start":39854,"node":225,"role":"declaration","source":0,"src_end":32263,"src_start":31917},{"artifact":1,"gen_end":41597,"gen_start":40303,"node":226,"role":"declaration","source":0,"src_end":33315,"src_start":32265},{"artifact":1,"gen_end":42056,"gen_start":41597,"node":227,"role":"declaration","source":0,"src_end":33673,"src_start":33317},{"artifact":1,"gen_end":43905,"gen_start":42056,"node":228,"role":"declaration","source":0,"src_end":35248,"src_start":33675},{"artifact":1,"gen_end":44346,"gen_start":43905,"node":229,"role":"declaration","source":0,"src_end":35590,"src_start":35250},{"artifact":1,"gen_end":45645,"gen_start":44346,"node":230,"role":"declaration","source":0,"src_end":36649,"src_start":35592},{"artifact":1,"gen_end":46135,"gen_start":45645,"node":231,"role":"declaration","source":0,"src_end":37040,"src_start":36651},{"artifact":1,"gen_end":47478,"gen_start":46135,"node":232,"role":"declaration","source":0,"src_end":38139,"src_start":37042},{"artifact":1,"gen_end":47972,"gen_start":47478,"node":233,"role":"declaration","source":0,"src_end":38532,"src_start":38141},{"artifact":1,"gen_end":49276,"gen_start":47972,"node":234,"role":"declaration","source":0,"src_end":39596,"src_start":38534},{"artifact":1,"gen_end":49772,"gen_start":49276,"node":235,"role":"declaration","source":0,"src_end":39993,"src_start":39598},{"artifact":1,"gen_end":51630,"gen_start":49772,"node":236,"role":"declaration","source":0,"src_end":41577,"src_start":39995},{"artifact":1,"gen_end":52118,"gen_start":51630,"node":237,"role":"declaration","source":0,"src_end":41966,"src_start":41579},{"artifact":1,"gen_end":53077,"gen_start":52118,"node":238,"role":"declaration","source":0,"src_end":42693,"src_start":41968},{"artifact":1,"gen_end":53581,"gen_start":53077,"node":239,"role":"declaration","source":0,"src_end":43090,"src_start":42695},{"artifact":1,"gen_end":54827,"gen_start":53581,"node":240,"role":"declaration","source":0,"src_end":44094,"src_start":43092},{"artifact":1,"gen_end":55333,"gen_start":54827,"node":241,"role":"declaration","source":0,"src_end":44493,"src_start":44096},{"artifact":1,"gen_end":56579,"gen_start":55333,"node":242,"role":"declaration","source":0,"src_end":45497,"src_start":44495},{"artifact":1,"gen_end":57085,"gen_start":56579,"node":243,"role":"declaration","source":0,"src_end":45896,"src_start":45499},{"artifact":1,"gen_end":58376,"gen_start":57085,"node":244,"role":"declaration","source":0,"src_end":46957,"src_start":45898},{"artifact":1,"gen_end":58888,"gen_start":58376,"node":245,"role":"declaration","source":0,"src_end":47362,"src_start":46959},{"artifact":1,"gen_end":60227,"gen_start":58888,"node":246,"role":"declaration","source":0,"src_end":48455,"src_start":47364},{"artifact":1,"gen_end":60648,"gen_start":60227,"node":247,"role":"declaration","source":0,"src_end":48783,"src_start":48457},{"artifact":1,"gen_end":61436,"gen_start":60648,"node":248,"role":"declaration","source":0,"src_end":49359,"src_start":48785},{"artifact":1,"gen_end":61939,"gen_start":61436,"node":249,"role":"declaration","source":0,"src_end":49761,"src_start":49361},{"artifact":1,"gen_end":63270,"gen_start":61939,"node":250,"role":"declaration","source":0,"src_end":50846,"src_start":49763},{"artifact":1,"gen_end":63747,"gen_start":63270,"node":251,"role":"declaration","source":0,"src_end":51224,"src_start":50848},{"artifact":1,"gen_end":65087,"gen_start":63747,"node":252,"role":"declaration","source":0,"src_end":52308,"src_start":51226},{"artifact":1,"gen_end":65541,"gen_start":65087,"node":253,"role":"declaration","source":0,"src_end":52661,"src_start":52310},{"artifact":1,"gen_end":66875,"gen_start":65541,"node":254,"role":"declaration","source":0,"src_end":53765,"src_start":52663},{"artifact":1,"gen_end":67329,"gen_start":66875,"node":255,"role":"declaration","source":0,"src_end":54118,"src_start":53767},{"artifact":1,"gen_end":68513,"gen_start":67329,"node":256,"role":"declaration","source":0,"src_end":55054,"src_start":54120},{"artifact":1,"gen_end":69038,"gen_start":68513,"node":257,"role":"declaration","source":0,"src_end":55472,"src_start":55056},{"artifact":1,"gen_end":70342,"gen_start":69038,"node":258,"role":"declaration","source":0,"src_end":56536,"src_start":55474},{"artifact":1,"gen_end":70854,"gen_start":70342,"node":259,"role":"declaration","source":0,"src_end":56941,"src_start":56538},{"artifact":1,"gen_end":72218,"gen_start":70854,"node":260,"role":"declaration","source":0,"src_end":58083,"src_start":56943},{"artifact":1,"gen_end":72726,"gen_start":72218,"node":261,"role":"declaration","source":0,"src_end":58484,"src_start":58085},{"artifact":1,"gen_end":73916,"gen_start":72726,"node":262,"role":"declaration","source":0,"src_end":59438,"src_start":58486},{"artifact":1,"gen_end":74343,"gen_start":73916,"node":263,"role":"declaration","source":0,"src_end":59772,"src_start":59440},{"artifact":1,"gen_end":75607,"gen_start":74343,"node":264,"role":"declaration","source":0,"src_end":60786,"src_start":59774},{"artifact":1,"gen_end":76111,"gen_start":75607,"node":265,"role":"declaration","source":0,"src_end":61183,"src_start":60788},{"artifact":1,"gen_end":77322,"gen_start":76111,"node":266,"role":"declaration","source":0,"src_end":62128,"src_start":61185},{"artifact":1,"gen_end":77784,"gen_start":77322,"node":267,"role":"declaration","source":0,"src_end":62489,"src_start":62130},{"artifact":1,"gen_end":79678,"gen_start":77784,"node":268,"role":"declaration","source":0,"src_end":64105,"src_start":62491},{"artifact":1,"gen_end":80164,"gen_start":79678,"node":269,"role":"declaration","source":0,"src_end":64484,"src_start":64107},{"artifact":1,"gen_end":82007,"gen_start":80164,"node":270,"role":"declaration","source":0,"src_end":66051,"src_start":64486},{"artifact":1,"gen_end":82494,"gen_start":82007,"node":271,"role":"declaration","source":0,"src_end":66431,"src_start":66053},{"artifact":1,"gen_end":83781,"gen_start":82494,"node":272,"role":"declaration","source":0,"src_end":67476,"src_start":66433},{"artifact":1,"gen_end":84279,"gen_start":83781,"node":273,"role":"declaration","source":0,"src_end":67867,"src_start":67478},{"artifact":1,"gen_end":85564,"gen_start":84279,"node":274,"role":"declaration","source":0,"src_end":68910,"src_start":67869},{"artifact":1,"gen_end":86056,"gen_start":85564,"node":275,"role":"declaration","source":0,"src_end":69295,"src_start":68912},{"artifact":1,"gen_end":87343,"gen_start":86056,"node":276,"role":"declaration","source":0,"src_end":70354,"src_start":69297},{"artifact":1,"gen_end":87857,"gen_start":87343,"node":277,"role":"declaration","source":0,"src_end":70761,"src_start":70356},{"artifact":1,"gen_end":89112,"gen_start":87857,"node":278,"role":"declaration","source":0,"src_end":71762,"src_start":70763},{"artifact":1,"gen_end":89626,"gen_start":89112,"node":279,"role":"declaration","source":0,"src_end":72169,"src_start":71764},{"artifact":1,"gen_end":90665,"gen_start":89626,"node":280,"role":"declaration","source":0,"src_end":72976,"src_start":72171},{"artifact":1,"gen_end":91175,"gen_start":90665,"node":281,"role":"declaration","source":0,"src_end":73379,"src_start":72978},{"artifact":1,"gen_end":92295,"gen_start":91175,"node":282,"role":"declaration","source":0,"src_end":74225,"src_start":73381},{"artifact":1,"gen_end":92790,"gen_start":92295,"node":283,"role":"declaration","source":0,"src_end":74619,"src_start":74227},{"artifact":1,"gen_end":93914,"gen_start":92790,"node":284,"role":"declaration","source":0,"src_end":75469,"src_start":74621},{"artifact":1,"gen_end":94419,"gen_start":93914,"node":285,"role":"declaration","source":0,"src_end":75869,"src_start":75471},{"artifact":1,"gen_end":95540,"gen_start":94419,"node":286,"role":"declaration","source":0,"src_end":76716,"src_start":75871},{"artifact":1,"gen_end":96037,"gen_start":95540,"node":287,"role":"declaration","source":0,"src_end":77112,"src_start":76718},{"artifact":1,"gen_end":97329,"gen_start":96037,"node":288,"role":"declaration","source":0,"src_end":78162,"src_start":77114},{"artifact":1,"gen_end":97757,"gen_start":97329,"node":289,"role":"declaration","source":0,"src_end":78499,"src_start":78164},{"artifact":1,"gen_end":98955,"gen_start":97757,"node":290,"role":"declaration","source":0,"src_end":79443,"src_start":78501},{"artifact":1,"gen_end":99473,"gen_start":98955,"node":291,"role":"declaration","source":0,"src_end":79860,"src_start":79445},{"artifact":1,"gen_end":99856,"gen_start":99473,"node":292,"role":"declaration","source":0,"src_end":80166,"src_start":79862},{"artifact":1,"gen_end":101054,"gen_start":99856,"node":293,"role":"declaration","source":0,"src_end":81114,"src_start":80168},{"artifact":1,"gen_end":101560,"gen_start":101054,"node":294,"role":"declaration","source":0,"src_end":81519,"src_start":81116},{"artifact":1,"gen_end":101930,"gen_start":101560,"node":295,"role":"declaration","source":0,"src_end":81812,"src_start":81521},{"artifact":1,"gen_end":103174,"gen_start":101930,"node":296,"role":"declaration","source":0,"src_end":82794,"src_start":81814},{"artifact":1,"gen_end":103680,"gen_start":103174,"node":297,"role":"declaration","source":0,"src_end":83199,"src_start":82796},{"artifact":1,"gen_end":104051,"gen_start":103680,"node":298,"role":"declaration","source":0,"src_end":83493,"src_start":83201},{"artifact":1,"gen_end":105147,"gen_start":104051,"node":299,"role":"declaration","source":0,"src_end":84351,"src_start":83495},{"artifact":1,"gen_end":105608,"gen_start":105147,"node":300,"role":"declaration","source":0,"src_end":84711,"src_start":84353},{"artifact":1,"gen_end":105973,"gen_start":105608,"node":301,"role":"declaration","source":0,"src_end":84999,"src_start":84713},{"artifact":1,"gen_end":106983,"gen_start":105973,"node":302,"role":"declaration","source":0,"src_end":85787,"src_start":85001},{"artifact":1,"gen_end":107489,"gen_start":106983,"node":303,"role":"declaration","source":0,"src_end":86192,"src_start":85789},{"artifact":1,"gen_end":108490,"gen_start":107489,"node":304,"role":"declaration","source":0,"src_end":86971,"src_start":86194},{"artifact":1,"gen_end":108947,"gen_start":108490,"node":305,"role":"declaration","source":0,"src_end":87331,"src_start":86973},{"artifact":1,"gen_end":110146,"gen_start":108947,"node":306,"role":"declaration","source":0,"src_end":88276,"src_start":87333},{"artifact":1,"gen_end":110611,"gen_start":110146,"node":307,"role":"declaration","source":0,"src_end":88640,"src_start":88278},{"artifact":1,"gen_end":110981,"gen_start":110611,"node":308,"role":"declaration","source":0,"src_end":88933,"src_start":88642},{"artifact":1,"gen_end":112193,"gen_start":110981,"node":309,"role":"declaration","source":0,"src_end":89891,"src_start":88935},{"artifact":1,"gen_end":112700,"gen_start":112193,"node":310,"role":"declaration","source":0,"src_end":90297,"src_start":89893},{"artifact":1,"gen_end":113072,"gen_start":112700,"node":311,"role":"declaration","source":0,"src_end":90592,"src_start":90299},{"artifact":1,"gen_end":114274,"gen_start":113072,"node":312,"role":"declaration","source":0,"src_end":91540,"src_start":90594},{"artifact":1,"gen_end":114734,"gen_start":114274,"node":313,"role":"declaration","source":0,"src_end":91899,"src_start":91542},{"artifact":1,"gen_end":115099,"gen_start":114734,"node":314,"role":"declaration","source":0,"src_end":92187,"src_start":91901},{"artifact":1,"gen_end":115801,"gen_start":115099,"node":315,"role":"declaration","source":0,"src_end":92691,"src_start":92189},{"artifact":1,"gen_end":116278,"gen_start":115801,"node":316,"role":"declaration","source":0,"src_end":93069,"src_start":92693},{"artifact":1,"gen_end":117080,"gen_start":116278,"node":317,"role":"declaration","source":0,"src_end":93661,"src_start":93071},{"artifact":1,"gen_end":117563,"gen_start":117080,"node":318,"role":"declaration","source":0,"src_end":94045,"src_start":93663},{"artifact":1,"gen_end":117934,"gen_start":117563,"node":319,"role":"declaration","source":0,"src_end":94339,"src_start":94047},{"artifact":1,"gen_end":119223,"gen_start":117934,"node":320,"role":"declaration","source":0,"src_end":95386,"src_start":94341},{"artifact":1,"gen_end":119640,"gen_start":119223,"node":321,"role":"declaration","source":0,"src_end":95712,"src_start":95388},{"artifact":1,"gen_end":120929,"gen_start":119640,"node":322,"role":"declaration","source":0,"src_end":96761,"src_start":95714},{"artifact":1,"gen_end":121357,"gen_start":120929,"node":323,"role":"declaration","source":0,"src_end":97098,"src_start":96763},{"artifact":1,"gen_end":122403,"gen_start":121357,"node":324,"role":"declaration","source":0,"src_end":97914,"src_start":97100},{"artifact":1,"gen_end":122843,"gen_start":122403,"node":325,"role":"declaration","source":0,"src_end":98263,"src_start":97916},{"artifact":1,"gen_end":124132,"gen_start":122843,"node":326,"role":"declaration","source":0,"src_end":99310,"src_start":98265},{"artifact":1,"gen_end":124548,"gen_start":124132,"node":327,"role":"declaration","source":0,"src_end":99635,"src_start":99312},{"artifact":1,"gen_end":125839,"gen_start":124548,"node":328,"role":"declaration","source":0,"src_end":100684,"src_start":99637},{"artifact":1,"gen_end":126264,"gen_start":125839,"node":329,"role":"declaration","source":0,"src_end":101018,"src_start":100686},{"artifact":1,"gen_end":126608,"gen_start":126264,"node":330,"role":"declaration","source":0,"src_end":101279,"src_start":101020},{"artifact":1,"gen_end":126954,"gen_start":126608,"node":331,"role":"declaration","source":0,"src_end":101542,"src_start":101281},{"artifact":1,"gen_end":127299,"gen_start":126954,"node":332,"role":"declaration","source":0,"src_end":101804,"src_start":101544},{"artifact":1,"gen_end":127645,"gen_start":127299,"node":333,"role":"declaration","source":0,"src_end":102067,"src_start":101806},{"artifact":1,"gen_end":127989,"gen_start":127645,"node":334,"role":"declaration","source":0,"src_end":102328,"src_start":102069},{"artifact":1,"gen_end":128334,"gen_start":127989,"node":335,"role":"declaration","source":0,"src_end":102590,"src_start":102330},{"artifact":1,"gen_end":128678,"gen_start":128334,"node":336,"role":"declaration","source":0,"src_end":102851,"src_start":102592},{"artifact":1,"gen_end":129024,"gen_start":128678,"node":337,"role":"declaration","source":0,"src_end":103114,"src_start":102853},{"artifact":1,"gen_end":129368,"gen_start":129024,"node":338,"role":"declaration","source":0,"src_end":103375,"src_start":103116},{"artifact":1,"gen_end":129713,"gen_start":129368,"node":339,"role":"declaration","source":0,"src_end":103637,"src_start":103377},{"artifact":1,"gen_end":130043,"gen_start":129713,"node":340,"role":"declaration","source":0,"src_end":103884,"src_start":103639},{"artifact":1,"gen_end":130375,"gen_start":130043,"node":341,"role":"declaration","source":0,"src_end":104133,"src_start":103886},{"artifact":1,"gen_end":130705,"gen_start":130375,"node":342,"role":"declaration","source":0,"src_end":104380,"src_start":104135},{"artifact":1,"gen_end":131036,"gen_start":130705,"node":343,"role":"declaration","source":0,"src_end":104628,"src_start":104382},{"artifact":1,"gen_end":131358,"gen_start":131036,"node":344,"role":"declaration","source":0,"src_end":104867,"src_start":104630},{"artifact":1,"gen_end":131682,"gen_start":131358,"node":345,"role":"declaration","source":0,"src_end":105108,"src_start":104869},{"artifact":1,"gen_end":132004,"gen_start":131682,"node":346,"role":"declaration","source":0,"src_end":105347,"src_start":105110},{"artifact":1,"gen_end":132327,"gen_start":132004,"node":347,"role":"declaration","source":0,"src_end":105587,"src_start":105349},{"artifact":1,"gen_end":132342,"gen_start":132327,"node":174,"role":"declaration","source":0,"src_end":105623,"src_start":0}],"module":"GnafCertificates","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-latex-module"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-declaration"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/GnafCertificates.lex.tex","sha256":"498dafa5093f56f0a05bbddb58875aebc0769325386f2ca611f3a101d9368f64"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/GnafFixtures.map.json b/compiler/expected/build/maps/LexLeanTarget/GnafFixtures.map.json index e6da3b682..4e4de95e2 100644 --- a/compiler/expected/build/maps/LexLeanTarget/GnafFixtures.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/GnafFixtures.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GnafFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GnafFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":327,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":0,"gen_end":10109,"gen_start":327,"node":1,"role":"declaration","source":0,"src_end":7817,"src_start":200},{"artifact":0,"gen_end":10564,"gen_start":10109,"node":2,"role":"declaration","source":0,"src_end":8234,"src_start":7819},{"artifact":0,"gen_end":11066,"gen_start":10564,"node":3,"role":"declaration","source":0,"src_end":8746,"src_start":8236},{"artifact":0,"gen_end":11237,"gen_start":11066,"node":4,"role":"declaration","source":0,"src_end":8987,"src_start":8748},{"artifact":0,"gen_end":21021,"gen_start":11237,"node":5,"role":"declaration","source":0,"src_end":16608,"src_start":8989},{"artifact":0,"gen_end":21482,"gen_start":21021,"node":6,"role":"declaration","source":0,"src_end":17031,"src_start":16610},{"artifact":0,"gen_end":21990,"gen_start":21482,"node":7,"role":"declaration","source":0,"src_end":17549,"src_start":17033},{"artifact":0,"gen_end":22167,"gen_start":21990,"node":8,"role":"declaration","source":0,"src_end":17796,"src_start":17551},{"artifact":0,"gen_end":35192,"gen_start":22167,"node":9,"role":"declaration","source":0,"src_end":27873,"src_start":17798},{"artifact":0,"gen_end":35950,"gen_start":35192,"node":10,"role":"declaration","source":0,"src_end":28537,"src_start":27875},{"artifact":0,"gen_end":36780,"gen_start":35950,"node":11,"role":"declaration","source":0,"src_end":29329,"src_start":28539},{"artifact":0,"gen_end":36948,"gen_start":36780,"node":12,"role":"declaration","source":0,"src_end":29569,"src_start":29331},{"artifact":0,"gen_end":57064,"gen_start":36948,"node":13,"role":"declaration","source":0,"src_end":45993,"src_start":29571},{"artifact":0,"gen_end":57529,"gen_start":57064,"node":14,"role":"declaration","source":0,"src_end":46420,"src_start":45995},{"artifact":0,"gen_end":58016,"gen_start":57529,"node":15,"role":"declaration","source":0,"src_end":46929,"src_start":46422},{"artifact":0,"gen_end":58168,"gen_start":58016,"node":16,"role":"declaration","source":0,"src_end":47161,"src_start":46931},{"artifact":0,"gen_end":68390,"gen_start":58168,"node":17,"role":"declaration","source":0,"src_end":55137,"src_start":47163},{"artifact":0,"gen_end":68723,"gen_start":68390,"node":18,"role":"declaration","source":0,"src_end":55460,"src_start":55139},{"artifact":0,"gen_end":69119,"gen_start":68723,"node":19,"role":"declaration","source":0,"src_end":55882,"src_start":55462},{"artifact":0,"gen_end":69297,"gen_start":69119,"node":20,"role":"declaration","source":0,"src_end":56130,"src_start":55884},{"artifact":0,"gen_end":79087,"gen_start":69297,"node":21,"role":"declaration","source":0,"src_end":63757,"src_start":56132},{"artifact":0,"gen_end":79554,"gen_start":79087,"node":22,"role":"declaration","source":0,"src_end":64186,"src_start":63759},{"artifact":0,"gen_end":80068,"gen_start":79554,"node":23,"role":"declaration","source":0,"src_end":64710,"src_start":64188},{"artifact":0,"gen_end":80254,"gen_start":80068,"node":24,"role":"declaration","source":0,"src_end":64970,"src_start":64712},{"artifact":0,"gen_end":100375,"gen_start":80254,"node":25,"role":"declaration","source":0,"src_end":81399,"src_start":64972},{"artifact":0,"gen_end":100846,"gen_start":100375,"node":26,"role":"declaration","source":0,"src_end":81832,"src_start":81401},{"artifact":0,"gen_end":101339,"gen_start":100846,"node":27,"role":"declaration","source":0,"src_end":82347,"src_start":81834},{"artifact":0,"gen_end":101497,"gen_start":101339,"node":28,"role":"declaration","source":0,"src_end":82585,"src_start":82349},{"artifact":0,"gen_end":111285,"gen_start":101497,"node":29,"role":"declaration","source":0,"src_end":90210,"src_start":82587},{"artifact":0,"gen_end":111754,"gen_start":111285,"node":30,"role":"declaration","source":0,"src_end":90641,"src_start":90212},{"artifact":0,"gen_end":112270,"gen_start":111754,"node":31,"role":"declaration","source":0,"src_end":91167,"src_start":90643},{"artifact":0,"gen_end":112458,"gen_start":112270,"node":32,"role":"declaration","source":0,"src_end":91429,"src_start":91169},{"artifact":0,"gen_end":125487,"gen_start":112458,"node":33,"role":"declaration","source":0,"src_end":101510,"src_start":91431},{"artifact":0,"gen_end":126249,"gen_start":125487,"node":34,"role":"declaration","source":0,"src_end":102178,"src_start":101512},{"artifact":0,"gen_end":127083,"gen_start":126249,"node":35,"role":"declaration","source":0,"src_end":102974,"src_start":102180},{"artifact":0,"gen_end":127258,"gen_start":127083,"node":36,"role":"declaration","source":0,"src_end":103225,"src_start":102976},{"artifact":0,"gen_end":135083,"gen_start":127258,"node":37,"role":"declaration","source":0,"src_end":109365,"src_start":103227},{"artifact":0,"gen_end":135558,"gen_start":135083,"node":38,"role":"declaration","source":0,"src_end":109802,"src_start":109367},{"artifact":0,"gen_end":136059,"gen_start":135558,"node":39,"role":"declaration","source":0,"src_end":110325,"src_start":109804},{"artifact":0,"gen_end":136250,"gen_start":136059,"node":40,"role":"declaration","source":0,"src_end":110586,"src_start":110327},{"artifact":0,"gen_end":142223,"gen_start":136250,"node":41,"role":"declaration","source":0,"src_end":115319,"src_start":110588},{"artifact":0,"gen_end":142427,"gen_start":142223,"node":42,"role":"declaration","source":0,"src_end":115531,"src_start":115321},{"artifact":0,"gen_end":142650,"gen_start":142427,"node":43,"role":"declaration","source":0,"src_end":115808,"src_start":115533},{"artifact":0,"gen_end":142800,"gen_start":142650,"node":44,"role":"declaration","source":0,"src_end":116038,"src_start":115810},{"artifact":0,"gen_end":152176,"gen_start":142800,"node":45,"role":"declaration","source":0,"src_end":123350,"src_start":116040},{"artifact":0,"gen_end":152649,"gen_start":152176,"node":46,"role":"declaration","source":0,"src_end":123785,"src_start":123352},{"artifact":0,"gen_end":153166,"gen_start":152649,"node":47,"role":"declaration","source":0,"src_end":124312,"src_start":123787},{"artifact":0,"gen_end":153354,"gen_start":153166,"node":48,"role":"declaration","source":0,"src_end":124570,"src_start":124314},{"artifact":0,"gen_end":162498,"gen_start":153354,"node":49,"role":"declaration","source":0,"src_end":131650,"src_start":124572},{"artifact":0,"gen_end":162973,"gen_start":162498,"node":50,"role":"declaration","source":0,"src_end":132087,"src_start":131652},{"artifact":0,"gen_end":163492,"gen_start":162973,"node":51,"role":"declaration","source":0,"src_end":132616,"src_start":132089},{"artifact":0,"gen_end":163682,"gen_start":163492,"node":52,"role":"declaration","source":0,"src_end":132876,"src_start":132618},{"artifact":0,"gen_end":183799,"gen_start":163682,"node":53,"role":"declaration","source":0,"src_end":149301,"src_start":132878},{"artifact":0,"gen_end":184268,"gen_start":183799,"node":54,"role":"declaration","source":0,"src_end":149732,"src_start":149303},{"artifact":0,"gen_end":184759,"gen_start":184268,"node":55,"role":"declaration","source":0,"src_end":150245,"src_start":149734},{"artifact":0,"gen_end":184915,"gen_start":184759,"node":56,"role":"declaration","source":0,"src_end":150481,"src_start":150247},{"artifact":0,"gen_end":197940,"gen_start":184915,"node":57,"role":"declaration","source":0,"src_end":160558,"src_start":150483},{"artifact":0,"gen_end":198700,"gen_start":197940,"node":58,"role":"declaration","source":0,"src_end":161224,"src_start":160560},{"artifact":0,"gen_end":199532,"gen_start":198700,"node":59,"role":"declaration","source":0,"src_end":162018,"src_start":161226},{"artifact":0,"gen_end":199702,"gen_start":199532,"node":60,"role":"declaration","source":0,"src_end":162260,"src_start":162020},{"artifact":0,"gen_end":209678,"gen_start":199702,"node":61,"role":"declaration","source":0,"src_end":170047,"src_start":162262},{"artifact":0,"gen_end":210141,"gen_start":209678,"node":62,"role":"declaration","source":0,"src_end":170472,"src_start":170049},{"artifact":0,"gen_end":210651,"gen_start":210141,"node":63,"role":"declaration","source":0,"src_end":170992,"src_start":170474},{"artifact":0,"gen_end":210830,"gen_start":210651,"node":64,"role":"declaration","source":0,"src_end":171241,"src_start":170994},{"artifact":0,"gen_end":220977,"gen_start":210830,"node":65,"role":"declaration","source":0,"src_end":179187,"src_start":171243},{"artifact":0,"gen_end":221446,"gen_start":220977,"node":66,"role":"declaration","source":0,"src_end":179618,"src_start":179189},{"artifact":0,"gen_end":221962,"gen_start":221446,"node":67,"role":"declaration","source":0,"src_end":180144,"src_start":179620},{"artifact":0,"gen_end":222147,"gen_start":221962,"node":68,"role":"declaration","source":0,"src_end":180399,"src_start":180146},{"artifact":0,"gen_end":232296,"gen_start":222147,"node":69,"role":"declaration","source":0,"src_end":188347,"src_start":180401},{"artifact":0,"gen_end":232767,"gen_start":232296,"node":70,"role":"declaration","source":0,"src_end":188780,"src_start":188349},{"artifact":0,"gen_end":233285,"gen_start":232767,"node":71,"role":"declaration","source":0,"src_end":189308,"src_start":188782},{"artifact":0,"gen_end":233472,"gen_start":233285,"node":72,"role":"declaration","source":0,"src_end":189565,"src_start":189310},{"artifact":0,"gen_end":304190,"gen_start":233472,"node":73,"role":"declaration","source":0,"src_end":244998,"src_start":189567},{"artifact":0,"gen_end":304474,"gen_start":304190,"node":74,"role":"declaration","source":0,"src_end":245278,"src_start":245000},{"artifact":0,"gen_end":304816,"gen_start":304474,"node":75,"role":"declaration","source":0,"src_end":245654,"src_start":245280},{"artifact":0,"gen_end":304990,"gen_start":304816,"node":76,"role":"declaration","source":0,"src_end":245898,"src_start":245656},{"artifact":0,"gen_end":375712,"gen_start":304990,"node":77,"role":"declaration","source":0,"src_end":301335,"src_start":245900},{"artifact":0,"gen_end":376000,"gen_start":375712,"node":78,"role":"declaration","source":0,"src_end":301619,"src_start":301337},{"artifact":0,"gen_end":376346,"gen_start":376000,"node":79,"role":"declaration","source":0,"src_end":301999,"src_start":301621},{"artifact":0,"gen_end":376519,"gen_start":376346,"node":80,"role":"declaration","source":0,"src_end":302244,"src_start":302001},{"artifact":0,"gen_end":386305,"gen_start":376519,"node":81,"role":"declaration","source":0,"src_end":309867,"src_start":302246},{"artifact":0,"gen_end":386772,"gen_start":386305,"node":82,"role":"declaration","source":0,"src_end":310296,"src_start":309869},{"artifact":0,"gen_end":386970,"gen_start":386772,"node":83,"role":"declaration","source":0,"src_end":310566,"src_start":310298},{"artifact":0,"gen_end":391377,"gen_start":386970,"node":84,"role":"declaration","source":0,"src_end":314109,"src_start":310568},{"artifact":0,"gen_end":391542,"gen_start":391377,"node":85,"role":"declaration","source":0,"src_end":314288,"src_start":314111},{"artifact":0,"gen_end":391740,"gen_start":391542,"node":86,"role":"declaration","source":0,"src_end":314558,"src_start":314290},{"artifact":0,"gen_end":401534,"gen_start":391740,"node":87,"role":"declaration","source":0,"src_end":322189,"src_start":314560},{"artifact":0,"gen_end":402013,"gen_start":401534,"node":88,"role":"declaration","source":0,"src_end":322630,"src_start":322191},{"artifact":0,"gen_end":402223,"gen_start":402013,"node":89,"role":"declaration","source":0,"src_end":322912,"src_start":322632},{"artifact":0,"gen_end":412143,"gen_start":402223,"node":90,"role":"declaration","source":0,"src_end":330649,"src_start":322914},{"artifact":0,"gen_end":412608,"gen_start":412143,"node":91,"role":"declaration","source":0,"src_end":331076,"src_start":330651},{"artifact":0,"gen_end":412854,"gen_start":412608,"node":92,"role":"declaration","source":0,"src_end":331386,"src_start":331078},{"artifact":0,"gen_end":422654,"gen_start":412854,"node":93,"role":"declaration","source":0,"src_end":339021,"src_start":331388},{"artifact":0,"gen_end":423133,"gen_start":422654,"node":94,"role":"declaration","source":0,"src_end":339462,"src_start":339023},{"artifact":0,"gen_end":423380,"gen_start":423133,"node":95,"role":"declaration","source":0,"src_end":339773,"src_start":339464},{"artifact":0,"gen_end":427829,"gen_start":423380,"node":96,"role":"declaration","source":0,"src_end":343352,"src_start":339775},{"artifact":0,"gen_end":428002,"gen_start":427829,"node":97,"role":"declaration","source":0,"src_end":343539,"src_start":343354},{"artifact":0,"gen_end":428212,"gen_start":428002,"node":98,"role":"declaration","source":0,"src_end":343821,"src_start":343541},{"artifact":0,"gen_end":438129,"gen_start":428212,"node":99,"role":"declaration","source":0,"src_end":351555,"src_start":343823},{"artifact":0,"gen_end":438598,"gen_start":438129,"node":100,"role":"declaration","source":0,"src_end":351986,"src_start":351557},{"artifact":0,"gen_end":438840,"gen_start":438598,"node":101,"role":"declaration","source":0,"src_end":352292,"src_start":351988},{"artifact":0,"gen_end":447563,"gen_start":438840,"node":102,"role":"declaration","source":0,"src_end":359050,"src_start":352294},{"artifact":0,"gen_end":448024,"gen_start":447563,"node":103,"role":"declaration","source":0,"src_end":359473,"src_start":359052},{"artifact":0,"gen_end":448213,"gen_start":448024,"node":104,"role":"declaration","source":0,"src_end":359734,"src_start":359475},{"artifact":0,"gen_end":458000,"gen_start":448213,"node":105,"role":"declaration","source":0,"src_end":367358,"src_start":359736},{"artifact":0,"gen_end":458469,"gen_start":458000,"node":106,"role":"declaration","source":0,"src_end":367789,"src_start":367360},{"artifact":0,"gen_end":458709,"gen_start":458469,"node":107,"role":"declaration","source":0,"src_end":368093,"src_start":367791},{"artifact":0,"gen_end":468648,"gen_start":458709,"node":108,"role":"declaration","source":0,"src_end":375849,"src_start":368095},{"artifact":0,"gen_end":469153,"gen_start":468648,"node":109,"role":"declaration","source":0,"src_end":376316,"src_start":375851},{"artifact":0,"gen_end":469439,"gen_start":469153,"node":110,"role":"declaration","source":0,"src_end":376666,"src_start":376318},{"artifact":0,"gen_end":479242,"gen_start":469439,"node":111,"role":"declaration","source":0,"src_end":384302,"src_start":376668},{"artifact":0,"gen_end":479721,"gen_start":479242,"node":112,"role":"declaration","source":0,"src_end":384743,"src_start":384304},{"artifact":0,"gen_end":479933,"gen_start":479721,"node":113,"role":"declaration","source":0,"src_end":385027,"src_start":384745},{"artifact":0,"gen_end":484353,"gen_start":479933,"node":114,"role":"declaration","source":0,"src_end":388583,"src_start":385029},{"artifact":0,"gen_end":484530,"gen_start":484353,"node":115,"role":"declaration","source":0,"src_end":388774,"src_start":388585},{"artifact":0,"gen_end":484746,"gen_start":484530,"node":116,"role":"declaration","source":0,"src_end":389062,"src_start":388776},{"artifact":0,"gen_end":494530,"gen_start":484746,"node":117,"role":"declaration","source":0,"src_end":396683,"src_start":389064},{"artifact":0,"gen_end":495007,"gen_start":494530,"node":118,"role":"declaration","source":0,"src_end":397122,"src_start":396685},{"artifact":0,"gen_end":495220,"gen_start":495007,"node":119,"role":"declaration","source":0,"src_end":397407,"src_start":397124},{"artifact":0,"gen_end":505013,"gen_start":495220,"node":120,"role":"declaration","source":0,"src_end":405037,"src_start":397409},{"artifact":0,"gen_end":505494,"gen_start":505013,"node":121,"role":"declaration","source":0,"src_end":405480,"src_start":405039},{"artifact":0,"gen_end":505713,"gen_start":505494,"node":122,"role":"declaration","source":0,"src_end":405771,"src_start":405482},{"artifact":0,"gen_end":510139,"gen_start":505713,"node":123,"role":"declaration","source":0,"src_end":409333,"src_start":405773},{"artifact":0,"gen_end":510324,"gen_start":510139,"node":124,"role":"declaration","source":0,"src_end":409532,"src_start":409335},{"artifact":0,"gen_end":510552,"gen_start":510324,"node":125,"role":"declaration","source":0,"src_end":409832,"src_start":409534},{"artifact":0,"gen_end":520418,"gen_start":510552,"node":126,"role":"declaration","source":0,"src_end":417529,"src_start":409834},{"artifact":0,"gen_end":520915,"gen_start":520418,"node":127,"role":"declaration","source":0,"src_end":417988,"src_start":417531},{"artifact":0,"gen_end":521145,"gen_start":520915,"node":128,"role":"declaration","source":0,"src_end":418290,"src_start":417990},{"artifact":0,"gen_end":531059,"gen_start":521145,"node":129,"role":"declaration","source":0,"src_end":426021,"src_start":418292},{"artifact":0,"gen_end":531518,"gen_start":531059,"node":130,"role":"declaration","source":0,"src_end":426442,"src_start":426023},{"artifact":0,"gen_end":531755,"gen_start":531518,"node":131,"role":"declaration","source":0,"src_end":426743,"src_start":426444},{"artifact":0,"gen_end":551125,"gen_start":531755,"node":132,"role":"declaration","source":0,"src_end":442012,"src_start":426745},{"artifact":0,"gen_end":551316,"gen_start":551125,"node":133,"role":"declaration","source":0,"src_end":442217,"src_start":442014},{"artifact":0,"gen_end":551544,"gen_start":551316,"node":134,"role":"declaration","source":0,"src_end":442517,"src_start":442219},{"artifact":0,"gen_end":622271,"gen_start":551544,"node":135,"role":"declaration","source":0,"src_end":497959,"src_start":442519},{"artifact":0,"gen_end":622575,"gen_start":622271,"node":136,"role":"declaration","source":0,"src_end":498259,"src_start":497961},{"artifact":0,"gen_end":622821,"gen_start":622575,"node":137,"role":"declaration","source":0,"src_end":498569,"src_start":498261},{"artifact":0,"gen_end":632629,"gen_start":622821,"node":138,"role":"declaration","source":0,"src_end":506214,"src_start":498571},{"artifact":0,"gen_end":633114,"gen_start":632629,"node":139,"role":"declaration","source":0,"src_end":506661,"src_start":506216},{"artifact":0,"gen_end":633326,"gen_start":633114,"node":140,"role":"declaration","source":0,"src_end":506945,"src_start":506663},{"artifact":0,"gen_end":643112,"gen_start":633326,"node":141,"role":"declaration","source":0,"src_end":514568,"src_start":506947},{"artifact":0,"gen_end":643583,"gen_start":643112,"node":142,"role":"declaration","source":0,"src_end":515001,"src_start":514570},{"artifact":0,"gen_end":643785,"gen_start":643583,"node":143,"role":"declaration","source":0,"src_end":515275,"src_start":515003},{"artifact":0,"gen_end":653581,"gen_start":643785,"node":144,"role":"declaration","source":0,"src_end":522908,"src_start":515277},{"artifact":0,"gen_end":654066,"gen_start":653581,"node":145,"role":"declaration","source":0,"src_end":523355,"src_start":522910},{"artifact":0,"gen_end":654295,"gen_start":654066,"node":146,"role":"declaration","source":0,"src_end":523656,"src_start":523357},{"artifact":0,"gen_end":664209,"gen_start":654295,"node":147,"role":"declaration","source":0,"src_end":531387,"src_start":523658},{"artifact":0,"gen_end":664668,"gen_start":664209,"node":148,"role":"declaration","source":0,"src_end":531808,"src_start":531389},{"artifact":0,"gen_end":664905,"gen_start":664668,"node":149,"role":"declaration","source":0,"src_end":532109,"src_start":531810},{"artifact":0,"gen_end":674705,"gen_start":664905,"node":150,"role":"declaration","source":0,"src_end":539746,"src_start":532111},{"artifact":0,"gen_end":675198,"gen_start":674705,"node":151,"role":"declaration","source":0,"src_end":540201,"src_start":539748},{"artifact":0,"gen_end":675435,"gen_start":675198,"node":152,"role":"declaration","source":0,"src_end":540510,"src_start":540203},{"artifact":0,"gen_end":685352,"gen_start":675435,"node":153,"role":"declaration","source":0,"src_end":548244,"src_start":540512},{"artifact":0,"gen_end":685825,"gen_start":685352,"node":154,"role":"declaration","source":0,"src_end":548679,"src_start":548246},{"artifact":0,"gen_end":686064,"gen_start":685825,"node":155,"role":"declaration","source":0,"src_end":548982,"src_start":548681},{"artifact":0,"gen_end":696163,"gen_start":686064,"node":156,"role":"declaration","source":0,"src_end":556882,"src_start":548984},{"artifact":0,"gen_end":696644,"gen_start":696163,"node":157,"role":"declaration","source":0,"src_end":557325,"src_start":556884},{"artifact":0,"gen_end":696902,"gen_start":696644,"node":158,"role":"declaration","source":0,"src_end":557647,"src_start":557327},{"artifact":0,"gen_end":706565,"gen_start":696902,"node":159,"role":"declaration","source":0,"src_end":565167,"src_start":557649},{"artifact":0,"gen_end":707042,"gen_start":706565,"node":160,"role":"declaration","source":0,"src_end":565606,"src_start":565169},{"artifact":0,"gen_end":707294,"gen_start":707042,"node":161,"role":"declaration","source":0,"src_end":565922,"src_start":565608},{"artifact":0,"gen_end":717142,"gen_start":707294,"node":162,"role":"declaration","source":0,"src_end":573603,"src_start":565924},{"artifact":0,"gen_end":717633,"gen_start":717142,"node":163,"role":"declaration","source":0,"src_end":574056,"src_start":573605},{"artifact":0,"gen_end":717904,"gen_start":717633,"node":164,"role":"declaration","source":0,"src_end":574391,"src_start":574058},{"artifact":0,"gen_end":727835,"gen_start":717904,"node":165,"role":"declaration","source":0,"src_end":582139,"src_start":574393},{"artifact":0,"gen_end":728314,"gen_start":727835,"node":166,"role":"declaration","source":0,"src_end":582580,"src_start":582141},{"artifact":0,"gen_end":728574,"gen_start":728314,"node":167,"role":"declaration","source":0,"src_end":582904,"src_start":582582},{"artifact":0,"gen_end":738371,"gen_start":728574,"node":168,"role":"declaration","source":0,"src_end":590538,"src_start":582906},{"artifact":0,"gen_end":738848,"gen_start":738371,"node":169,"role":"declaration","source":0,"src_end":590977,"src_start":590540},{"artifact":0,"gen_end":739094,"gen_start":738848,"node":170,"role":"declaration","source":0,"src_end":591287,"src_start":590979},{"artifact":0,"gen_end":749029,"gen_start":739094,"node":171,"role":"declaration","source":0,"src_end":599039,"src_start":591289},{"artifact":0,"gen_end":749514,"gen_start":749029,"node":172,"role":"declaration","source":0,"src_end":599486,"src_start":599041},{"artifact":0,"gen_end":749772,"gen_start":749514,"node":173,"role":"declaration","source":0,"src_end":599808,"src_start":599488},{"artifact":0,"gen_end":759557,"gen_start":749772,"node":174,"role":"declaration","source":0,"src_end":607430,"src_start":599810},{"artifact":0,"gen_end":760028,"gen_start":759557,"node":175,"role":"declaration","source":0,"src_end":607863,"src_start":607432},{"artifact":0,"gen_end":760232,"gen_start":760028,"node":176,"role":"declaration","source":0,"src_end":608139,"src_start":607865},{"artifact":0,"gen_end":770017,"gen_start":760232,"node":177,"role":"declaration","source":0,"src_end":615761,"src_start":608141},{"artifact":0,"gen_end":770488,"gen_start":770017,"node":178,"role":"declaration","source":0,"src_end":616194,"src_start":615763},{"artifact":0,"gen_end":770692,"gen_start":770488,"node":179,"role":"declaration","source":0,"src_end":616470,"src_start":616196},{"artifact":0,"gen_end":780489,"gen_start":770692,"node":180,"role":"declaration","source":0,"src_end":624104,"src_start":616472},{"artifact":0,"gen_end":780970,"gen_start":780489,"node":181,"role":"declaration","source":0,"src_end":624547,"src_start":624106},{"artifact":0,"gen_end":781193,"gen_start":780970,"node":182,"role":"declaration","source":0,"src_end":624842,"src_start":624549},{"artifact":0,"gen_end":790989,"gen_start":781193,"node":183,"role":"declaration","source":0,"src_end":632473,"src_start":624844},{"artifact":0,"gen_end":791460,"gen_start":790989,"node":184,"role":"declaration","source":0,"src_end":632906,"src_start":632475},{"artifact":0,"gen_end":791699,"gen_start":791460,"node":185,"role":"declaration","source":0,"src_end":633209,"src_start":632908},{"artifact":0,"gen_end":801634,"gen_start":791699,"node":186,"role":"declaration","source":0,"src_end":640959,"src_start":633211},{"artifact":0,"gen_end":802115,"gen_start":801634,"node":187,"role":"declaration","source":0,"src_end":641402,"src_start":640961},{"artifact":0,"gen_end":802369,"gen_start":802115,"node":188,"role":"declaration","source":0,"src_end":641720,"src_start":641404},{"artifact":0,"gen_end":811456,"gen_start":802369,"node":189,"role":"declaration","source":0,"src_end":648764,"src_start":641722},{"artifact":0,"gen_end":811909,"gen_start":811456,"node":190,"role":"declaration","source":0,"src_end":649179,"src_start":648766},{"artifact":0,"gen_end":812405,"gen_start":811909,"node":191,"role":"declaration","source":0,"src_end":649685,"src_start":649181},{"artifact":0,"gen_end":812573,"gen_start":812405,"node":192,"role":"declaration","source":0,"src_end":649923,"src_start":649687},{"artifact":0,"gen_end":822900,"gen_start":812573,"node":193,"role":"declaration","source":0,"src_end":657956,"src_start":649925},{"artifact":0,"gen_end":823196,"gen_start":822900,"node":194,"role":"declaration","source":0,"src_end":658248,"src_start":657958},{"artifact":0,"gen_end":823535,"gen_start":823196,"node":195,"role":"declaration","source":0,"src_end":658625,"src_start":658250},{"artifact":0,"gen_end":823691,"gen_start":823535,"node":196,"role":"declaration","source":0,"src_end":658861,"src_start":658627},{"artifact":0,"gen_end":837567,"gen_start":823691,"node":197,"role":"declaration","source":0,"src_end":669575,"src_start":658863},{"artifact":0,"gen_end":837902,"gen_start":837567,"node":198,"role":"declaration","source":0,"src_end":669900,"src_start":669577},{"artifact":0,"gen_end":838300,"gen_start":837902,"node":199,"role":"declaration","source":0,"src_end":670324,"src_start":669902},{"artifact":0,"gen_end":838491,"gen_start":838300,"node":200,"role":"declaration","source":0,"src_end":670591,"src_start":670326},{"artifact":0,"gen_end":838686,"gen_start":838491,"node":201,"role":"declaration","source":0,"src_end":670858,"src_start":670593},{"artifact":0,"gen_end":838881,"gen_start":838686,"node":202,"role":"declaration","source":0,"src_end":671125,"src_start":670860},{"artifact":0,"gen_end":839076,"gen_start":838881,"node":203,"role":"declaration","source":0,"src_end":671392,"src_start":671127},{"artifact":0,"gen_end":839280,"gen_start":839076,"node":204,"role":"declaration","source":0,"src_end":671670,"src_start":671394},{"artifact":0,"gen_end":839419,"gen_start":839280,"node":205,"role":"declaration","source":0,"src_end":671895,"src_start":671672},{"artifact":0,"gen_end":849199,"gen_start":839419,"node":206,"role":"declaration","source":0,"src_end":679512,"src_start":671897},{"artifact":0,"gen_end":849652,"gen_start":849199,"node":207,"role":"declaration","source":0,"src_end":679927,"src_start":679514},{"artifact":0,"gen_end":850152,"gen_start":849652,"node":208,"role":"declaration","source":0,"src_end":680437,"src_start":679929},{"artifact":0,"gen_end":850321,"gen_start":850152,"node":209,"role":"declaration","source":0,"src_end":680676,"src_start":680439},{"artifact":0,"gen_end":850353,"gen_start":850321,"node":0,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":210,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":1,"gen_end":10174,"gen_start":134,"node":211,"role":"declaration","source":0,"src_end":7817,"src_start":200},{"artifact":1,"gen_end":10738,"gen_start":10174,"node":212,"role":"declaration","source":0,"src_end":8234,"src_start":7819},{"artifact":1,"gen_end":11390,"gen_start":10738,"node":213,"role":"declaration","source":0,"src_end":8746,"src_start":8236},{"artifact":1,"gen_end":11711,"gen_start":11390,"node":214,"role":"declaration","source":0,"src_end":8987,"src_start":8748},{"artifact":1,"gen_end":21753,"gen_start":11711,"node":215,"role":"declaration","source":0,"src_end":16608,"src_start":8989},{"artifact":1,"gen_end":22323,"gen_start":21753,"node":216,"role":"declaration","source":0,"src_end":17031,"src_start":16610},{"artifact":1,"gen_end":22981,"gen_start":22323,"node":217,"role":"declaration","source":0,"src_end":17549,"src_start":17033},{"artifact":1,"gen_end":23308,"gen_start":22981,"node":218,"role":"declaration","source":0,"src_end":17796,"src_start":17551},{"artifact":1,"gen_end":36619,"gen_start":23308,"node":219,"role":"declaration","source":0,"src_end":27873,"src_start":17798},{"artifact":1,"gen_end":37486,"gen_start":36619,"node":220,"role":"declaration","source":0,"src_end":28537,"src_start":27875},{"artifact":1,"gen_end":38466,"gen_start":37486,"node":221,"role":"declaration","source":0,"src_end":29329,"src_start":28539},{"artifact":1,"gen_end":38784,"gen_start":38466,"node":222,"role":"declaration","source":0,"src_end":29569,"src_start":29331},{"artifact":1,"gen_end":59158,"gen_start":38784,"node":223,"role":"declaration","source":0,"src_end":45993,"src_start":29571},{"artifact":1,"gen_end":59732,"gen_start":59158,"node":224,"role":"declaration","source":0,"src_end":46420,"src_start":45995},{"artifact":1,"gen_end":60369,"gen_start":59732,"node":225,"role":"declaration","source":0,"src_end":46929,"src_start":46422},{"artifact":1,"gen_end":60671,"gen_start":60369,"node":226,"role":"declaration","source":0,"src_end":47161,"src_start":46931},{"artifact":1,"gen_end":71183,"gen_start":60671,"node":227,"role":"declaration","source":0,"src_end":55137,"src_start":47163},{"artifact":1,"gen_end":71625,"gen_start":71183,"node":228,"role":"declaration","source":0,"src_end":55460,"src_start":55139},{"artifact":1,"gen_end":72171,"gen_start":71625,"node":229,"role":"declaration","source":0,"src_end":55882,"src_start":55462},{"artifact":1,"gen_end":72499,"gen_start":72171,"node":230,"role":"declaration","source":0,"src_end":56130,"src_start":55884},{"artifact":1,"gen_end":82547,"gen_start":72499,"node":231,"role":"declaration","source":0,"src_end":63757,"src_start":56132},{"artifact":1,"gen_end":83123,"gen_start":82547,"node":232,"role":"declaration","source":0,"src_end":64186,"src_start":63759},{"artifact":1,"gen_end":83787,"gen_start":83123,"node":233,"role":"declaration","source":0,"src_end":64710,"src_start":64188},{"artifact":1,"gen_end":84123,"gen_start":83787,"node":234,"role":"declaration","source":0,"src_end":64970,"src_start":64712},{"artifact":1,"gen_end":104502,"gen_start":84123,"node":235,"role":"declaration","source":0,"src_end":81399,"src_start":64972},{"artifact":1,"gen_end":105082,"gen_start":104502,"node":236,"role":"declaration","source":0,"src_end":81832,"src_start":81401},{"artifact":1,"gen_end":105725,"gen_start":105082,"node":237,"role":"declaration","source":0,"src_end":82347,"src_start":81834},{"artifact":1,"gen_end":106033,"gen_start":105725,"node":238,"role":"declaration","source":0,"src_end":82585,"src_start":82349},{"artifact":1,"gen_end":116079,"gen_start":106033,"node":239,"role":"declaration","source":0,"src_end":90210,"src_start":82587},{"artifact":1,"gen_end":116657,"gen_start":116079,"node":240,"role":"declaration","source":0,"src_end":90641,"src_start":90212},{"artifact":1,"gen_end":117323,"gen_start":116657,"node":241,"role":"declaration","source":0,"src_end":91167,"src_start":90643},{"artifact":1,"gen_end":117661,"gen_start":117323,"node":242,"role":"declaration","source":0,"src_end":91429,"src_start":91169},{"artifact":1,"gen_end":130976,"gen_start":117661,"node":243,"role":"declaration","source":0,"src_end":101510,"src_start":91431},{"artifact":1,"gen_end":131847,"gen_start":130976,"node":244,"role":"declaration","source":0,"src_end":102178,"src_start":101512},{"artifact":1,"gen_end":132831,"gen_start":131847,"node":245,"role":"declaration","source":0,"src_end":102974,"src_start":102180},{"artifact":1,"gen_end":133156,"gen_start":132831,"node":246,"role":"declaration","source":0,"src_end":103225,"src_start":102976},{"artifact":1,"gen_end":141227,"gen_start":133156,"node":247,"role":"declaration","source":0,"src_end":109365,"src_start":103227},{"artifact":1,"gen_end":141811,"gen_start":141227,"node":248,"role":"declaration","source":0,"src_end":109802,"src_start":109367},{"artifact":1,"gen_end":142462,"gen_start":141811,"node":249,"role":"declaration","source":0,"src_end":110325,"src_start":109804},{"artifact":1,"gen_end":142803,"gen_start":142462,"node":250,"role":"declaration","source":0,"src_end":110586,"src_start":110327},{"artifact":1,"gen_end":148994,"gen_start":142803,"node":251,"role":"declaration","source":0,"src_end":115319,"src_start":110588},{"artifact":1,"gen_end":149307,"gen_start":148994,"node":252,"role":"declaration","source":0,"src_end":115531,"src_start":115321},{"artifact":1,"gen_end":149680,"gen_start":149307,"node":253,"role":"declaration","source":0,"src_end":115808,"src_start":115533},{"artifact":1,"gen_end":149980,"gen_start":149680,"node":254,"role":"declaration","source":0,"src_end":116038,"src_start":115810},{"artifact":1,"gen_end":159614,"gen_start":149980,"node":255,"role":"declaration","source":0,"src_end":123350,"src_start":116040},{"artifact":1,"gen_end":160196,"gen_start":159614,"node":256,"role":"declaration","source":0,"src_end":123785,"src_start":123352},{"artifact":1,"gen_end":160863,"gen_start":160196,"node":257,"role":"declaration","source":0,"src_end":124312,"src_start":123787},{"artifact":1,"gen_end":161201,"gen_start":160863,"node":258,"role":"declaration","source":0,"src_end":124570,"src_start":124314},{"artifact":1,"gen_end":170603,"gen_start":161201,"node":259,"role":"declaration","source":0,"src_end":131650,"src_start":124572},{"artifact":1,"gen_end":171187,"gen_start":170603,"node":260,"role":"declaration","source":0,"src_end":132087,"src_start":131652},{"artifact":1,"gen_end":171856,"gen_start":171187,"node":261,"role":"declaration","source":0,"src_end":132616,"src_start":132089},{"artifact":1,"gen_end":172196,"gen_start":171856,"node":262,"role":"declaration","source":0,"src_end":132876,"src_start":132618},{"artifact":1,"gen_end":192571,"gen_start":172196,"node":263,"role":"declaration","source":0,"src_end":149301,"src_start":132878},{"artifact":1,"gen_end":193149,"gen_start":192571,"node":264,"role":"declaration","source":0,"src_end":149732,"src_start":149303},{"artifact":1,"gen_end":193790,"gen_start":193149,"node":265,"role":"declaration","source":0,"src_end":150245,"src_start":149734},{"artifact":1,"gen_end":194096,"gen_start":193790,"node":266,"role":"declaration","source":0,"src_end":150481,"src_start":150247},{"artifact":1,"gen_end":207407,"gen_start":194096,"node":267,"role":"declaration","source":0,"src_end":160558,"src_start":150483},{"artifact":1,"gen_end":208276,"gen_start":207407,"node":268,"role":"declaration","source":0,"src_end":161224,"src_start":160560},{"artifact":1,"gen_end":209258,"gen_start":208276,"node":269,"role":"declaration","source":0,"src_end":162018,"src_start":161226},{"artifact":1,"gen_end":209578,"gen_start":209258,"node":270,"role":"declaration","source":0,"src_end":162260,"src_start":162020},{"artifact":1,"gen_end":219814,"gen_start":209578,"node":271,"role":"declaration","source":0,"src_end":170047,"src_start":162262},{"artifact":1,"gen_end":220386,"gen_start":219814,"node":272,"role":"declaration","source":0,"src_end":170472,"src_start":170049},{"artifact":1,"gen_end":221046,"gen_start":220386,"node":273,"role":"declaration","source":0,"src_end":170992,"src_start":170474},{"artifact":1,"gen_end":221375,"gen_start":221046,"node":274,"role":"declaration","source":0,"src_end":171241,"src_start":170994},{"artifact":1,"gen_end":231784,"gen_start":221375,"node":275,"role":"declaration","source":0,"src_end":179187,"src_start":171243},{"artifact":1,"gen_end":232362,"gen_start":231784,"node":276,"role":"declaration","source":0,"src_end":179618,"src_start":179189},{"artifact":1,"gen_end":233028,"gen_start":232362,"node":277,"role":"declaration","source":0,"src_end":180144,"src_start":179620},{"artifact":1,"gen_end":233363,"gen_start":233028,"node":278,"role":"declaration","source":0,"src_end":180399,"src_start":180146},{"artifact":1,"gen_end":243774,"gen_start":233363,"node":279,"role":"declaration","source":0,"src_end":188347,"src_start":180401},{"artifact":1,"gen_end":244354,"gen_start":243774,"node":280,"role":"declaration","source":0,"src_end":188780,"src_start":188349},{"artifact":1,"gen_end":245022,"gen_start":244354,"node":281,"role":"declaration","source":0,"src_end":189308,"src_start":188782},{"artifact":1,"gen_end":245359,"gen_start":245022,"node":282,"role":"declaration","source":0,"src_end":189565,"src_start":189310},{"artifact":1,"gen_end":316303,"gen_start":245359,"node":283,"role":"declaration","source":0,"src_end":244998,"src_start":189567},{"artifact":1,"gen_end":316696,"gen_start":316303,"node":284,"role":"declaration","source":0,"src_end":245278,"src_start":245000},{"artifact":1,"gen_end":317188,"gen_start":316696,"node":285,"role":"declaration","source":0,"src_end":245654,"src_start":245280},{"artifact":1,"gen_end":317512,"gen_start":317188,"node":286,"role":"declaration","source":0,"src_end":245898,"src_start":245656},{"artifact":1,"gen_end":388460,"gen_start":317512,"node":287,"role":"declaration","source":0,"src_end":301335,"src_start":245900},{"artifact":1,"gen_end":388857,"gen_start":388460,"node":288,"role":"declaration","source":0,"src_end":301619,"src_start":301337},{"artifact":1,"gen_end":389353,"gen_start":388857,"node":289,"role":"declaration","source":0,"src_end":301999,"src_start":301621},{"artifact":1,"gen_end":389676,"gen_start":389353,"node":290,"role":"declaration","source":0,"src_end":302244,"src_start":302001},{"artifact":1,"gen_end":399720,"gen_start":389676,"node":291,"role":"declaration","source":0,"src_end":309867,"src_start":302246},{"artifact":1,"gen_end":400296,"gen_start":399720,"node":292,"role":"declaration","source":0,"src_end":310296,"src_start":309869},{"artifact":1,"gen_end":400644,"gen_start":400296,"node":293,"role":"declaration","source":0,"src_end":310566,"src_start":310298},{"artifact":1,"gen_end":405251,"gen_start":400644,"node":294,"role":"declaration","source":0,"src_end":314109,"src_start":310568},{"artifact":1,"gen_end":405525,"gen_start":405251,"node":295,"role":"declaration","source":0,"src_end":314288,"src_start":314111},{"artifact":1,"gen_end":405873,"gen_start":405525,"node":296,"role":"declaration","source":0,"src_end":314558,"src_start":314290},{"artifact":1,"gen_end":415925,"gen_start":405873,"node":297,"role":"declaration","source":0,"src_end":322189,"src_start":314560},{"artifact":1,"gen_end":416513,"gen_start":415925,"node":298,"role":"declaration","source":0,"src_end":322630,"src_start":322191},{"artifact":1,"gen_end":416873,"gen_start":416513,"node":299,"role":"declaration","source":0,"src_end":322912,"src_start":322632},{"artifact":1,"gen_end":427053,"gen_start":416873,"node":300,"role":"declaration","source":0,"src_end":330649,"src_start":322914},{"artifact":1,"gen_end":427627,"gen_start":427053,"node":301,"role":"declaration","source":0,"src_end":331076,"src_start":330651},{"artifact":1,"gen_end":428023,"gen_start":427627,"node":302,"role":"declaration","source":0,"src_end":331386,"src_start":331078},{"artifact":1,"gen_end":438081,"gen_start":428023,"node":303,"role":"declaration","source":0,"src_end":339021,"src_start":331388},{"artifact":1,"gen_end":438669,"gen_start":438081,"node":304,"role":"declaration","source":0,"src_end":339462,"src_start":339023},{"artifact":1,"gen_end":439066,"gen_start":438669,"node":305,"role":"declaration","source":0,"src_end":339773,"src_start":339464},{"artifact":1,"gen_end":443715,"gen_start":439066,"node":306,"role":"declaration","source":0,"src_end":343352,"src_start":339775},{"artifact":1,"gen_end":443997,"gen_start":443715,"node":307,"role":"declaration","source":0,"src_end":343539,"src_start":343354},{"artifact":1,"gen_end":444357,"gen_start":443997,"node":308,"role":"declaration","source":0,"src_end":343821,"src_start":343541},{"artifact":1,"gen_end":454534,"gen_start":444357,"node":309,"role":"declaration","source":0,"src_end":351555,"src_start":343823},{"artifact":1,"gen_end":455112,"gen_start":454534,"node":310,"role":"declaration","source":0,"src_end":351986,"src_start":351557},{"artifact":1,"gen_end":455504,"gen_start":455112,"node":311,"role":"declaration","source":0,"src_end":352292,"src_start":351988},{"artifact":1,"gen_end":464485,"gen_start":455504,"node":312,"role":"declaration","source":0,"src_end":359050,"src_start":352294},{"artifact":1,"gen_end":465055,"gen_start":464485,"node":313,"role":"declaration","source":0,"src_end":359473,"src_start":359052},{"artifact":1,"gen_end":465394,"gen_start":465055,"node":314,"role":"declaration","source":0,"src_end":359734,"src_start":359475},{"artifact":1,"gen_end":475439,"gen_start":465394,"node":315,"role":"declaration","source":0,"src_end":367358,"src_start":359736},{"artifact":1,"gen_end":476017,"gen_start":475439,"node":316,"role":"declaration","source":0,"src_end":367789,"src_start":367360},{"artifact":1,"gen_end":476407,"gen_start":476017,"node":317,"role":"declaration","source":0,"src_end":368093,"src_start":367791},{"artifact":1,"gen_end":486606,"gen_start":476407,"node":318,"role":"declaration","source":0,"src_end":375849,"src_start":368095},{"artifact":1,"gen_end":487220,"gen_start":486606,"node":319,"role":"declaration","source":0,"src_end":376316,"src_start":375851},{"artifact":1,"gen_end":487656,"gen_start":487220,"node":320,"role":"declaration","source":0,"src_end":376666,"src_start":376318},{"artifact":1,"gen_end":497717,"gen_start":487656,"node":321,"role":"declaration","source":0,"src_end":384302,"src_start":376668},{"artifact":1,"gen_end":498305,"gen_start":497717,"node":322,"role":"declaration","source":0,"src_end":384743,"src_start":384304},{"artifact":1,"gen_end":498667,"gen_start":498305,"node":323,"role":"declaration","source":0,"src_end":385027,"src_start":384745},{"artifact":1,"gen_end":503287,"gen_start":498667,"node":324,"role":"declaration","source":0,"src_end":388583,"src_start":385029},{"artifact":1,"gen_end":503573,"gen_start":503287,"node":325,"role":"declaration","source":0,"src_end":388774,"src_start":388585},{"artifact":1,"gen_end":503939,"gen_start":503573,"node":326,"role":"declaration","source":0,"src_end":389062,"src_start":388776},{"artifact":1,"gen_end":513981,"gen_start":503939,"node":327,"role":"declaration","source":0,"src_end":396683,"src_start":389064},{"artifact":1,"gen_end":514567,"gen_start":513981,"node":328,"role":"declaration","source":0,"src_end":397122,"src_start":396685},{"artifact":1,"gen_end":514930,"gen_start":514567,"node":329,"role":"declaration","source":0,"src_end":397407,"src_start":397124},{"artifact":1,"gen_end":524981,"gen_start":514930,"node":330,"role":"declaration","source":0,"src_end":405037,"src_start":397409},{"artifact":1,"gen_end":525571,"gen_start":524981,"node":331,"role":"declaration","source":0,"src_end":405480,"src_start":405039},{"artifact":1,"gen_end":525940,"gen_start":525571,"node":332,"role":"declaration","source":0,"src_end":405771,"src_start":405482},{"artifact":1,"gen_end":530566,"gen_start":525940,"node":333,"role":"declaration","source":0,"src_end":409333,"src_start":405773},{"artifact":1,"gen_end":530860,"gen_start":530566,"node":334,"role":"declaration","source":0,"src_end":409532,"src_start":409335},{"artifact":1,"gen_end":531238,"gen_start":530860,"node":335,"role":"declaration","source":0,"src_end":409832,"src_start":409534},{"artifact":1,"gen_end":541362,"gen_start":531238,"node":336,"role":"declaration","source":0,"src_end":417529,"src_start":409834},{"artifact":1,"gen_end":541968,"gen_start":541362,"node":337,"role":"declaration","source":0,"src_end":417988,"src_start":417531},{"artifact":1,"gen_end":542348,"gen_start":541968,"node":338,"role":"declaration","source":0,"src_end":418290,"src_start":417990},{"artifact":1,"gen_end":552522,"gen_start":542348,"node":339,"role":"declaration","source":0,"src_end":426021,"src_start":418292},{"artifact":1,"gen_end":553090,"gen_start":552522,"node":340,"role":"declaration","source":0,"src_end":426442,"src_start":426023},{"artifact":1,"gen_end":553477,"gen_start":553090,"node":341,"role":"declaration","source":0,"src_end":426743,"src_start":426444},{"artifact":1,"gen_end":573023,"gen_start":553477,"node":342,"role":"declaration","source":0,"src_end":442012,"src_start":426745},{"artifact":1,"gen_end":573323,"gen_start":573023,"node":343,"role":"declaration","source":0,"src_end":442217,"src_start":442014},{"artifact":1,"gen_end":573701,"gen_start":573323,"node":344,"role":"declaration","source":0,"src_end":442517,"src_start":442219},{"artifact":1,"gen_end":644654,"gen_start":573701,"node":345,"role":"declaration","source":0,"src_end":497959,"src_start":442519},{"artifact":1,"gen_end":645067,"gen_start":644654,"node":346,"role":"declaration","source":0,"src_end":498259,"src_start":497961},{"artifact":1,"gen_end":645463,"gen_start":645067,"node":347,"role":"declaration","source":0,"src_end":498569,"src_start":498261},{"artifact":1,"gen_end":655529,"gen_start":645463,"node":348,"role":"declaration","source":0,"src_end":506214,"src_start":498571},{"artifact":1,"gen_end":656123,"gen_start":655529,"node":349,"role":"declaration","source":0,"src_end":506661,"src_start":506216},{"artifact":1,"gen_end":656485,"gen_start":656123,"node":350,"role":"declaration","source":0,"src_end":506945,"src_start":506663},{"artifact":1,"gen_end":666529,"gen_start":656485,"node":351,"role":"declaration","source":0,"src_end":514568,"src_start":506947},{"artifact":1,"gen_end":667109,"gen_start":666529,"node":352,"role":"declaration","source":0,"src_end":515001,"src_start":514570},{"artifact":1,"gen_end":667461,"gen_start":667109,"node":353,"role":"declaration","source":0,"src_end":515275,"src_start":515003},{"artifact":1,"gen_end":677515,"gen_start":667461,"node":354,"role":"declaration","source":0,"src_end":522908,"src_start":515277},{"artifact":1,"gen_end":678109,"gen_start":677515,"node":355,"role":"declaration","source":0,"src_end":523355,"src_start":522910},{"artifact":1,"gen_end":678488,"gen_start":678109,"node":356,"role":"declaration","source":0,"src_end":523656,"src_start":523357},{"artifact":1,"gen_end":688662,"gen_start":678488,"node":357,"role":"declaration","source":0,"src_end":531387,"src_start":523658},{"artifact":1,"gen_end":689230,"gen_start":688662,"node":358,"role":"declaration","source":0,"src_end":531808,"src_start":531389},{"artifact":1,"gen_end":689617,"gen_start":689230,"node":359,"role":"declaration","source":0,"src_end":532109,"src_start":531810},{"artifact":1,"gen_end":699675,"gen_start":689617,"node":360,"role":"declaration","source":0,"src_end":539746,"src_start":532111},{"artifact":1,"gen_end":700277,"gen_start":699675,"node":361,"role":"declaration","source":0,"src_end":540201,"src_start":539748},{"artifact":1,"gen_end":700664,"gen_start":700277,"node":362,"role":"declaration","source":0,"src_end":540510,"src_start":540203},{"artifact":1,"gen_end":710841,"gen_start":700664,"node":363,"role":"declaration","source":0,"src_end":548244,"src_start":540512},{"artifact":1,"gen_end":711423,"gen_start":710841,"node":364,"role":"declaration","source":0,"src_end":548679,"src_start":548246},{"artifact":1,"gen_end":711812,"gen_start":711423,"node":365,"role":"declaration","source":0,"src_end":548982,"src_start":548681},{"artifact":1,"gen_end":722173,"gen_start":711812,"node":366,"role":"declaration","source":0,"src_end":556882,"src_start":548984},{"artifact":1,"gen_end":722763,"gen_start":722173,"node":367,"role":"declaration","source":0,"src_end":557325,"src_start":556884},{"artifact":1,"gen_end":723171,"gen_start":722763,"node":368,"role":"declaration","source":0,"src_end":557647,"src_start":557327},{"artifact":1,"gen_end":733090,"gen_start":723171,"node":369,"role":"declaration","source":0,"src_end":565167,"src_start":557649},{"artifact":1,"gen_end":733676,"gen_start":733090,"node":370,"role":"declaration","source":0,"src_end":565606,"src_start":565169},{"artifact":1,"gen_end":734078,"gen_start":733676,"node":371,"role":"declaration","source":0,"src_end":565922,"src_start":565608},{"artifact":1,"gen_end":744184,"gen_start":734078,"node":372,"role":"declaration","source":0,"src_end":573603,"src_start":565924},{"artifact":1,"gen_end":744784,"gen_start":744184,"node":373,"role":"declaration","source":0,"src_end":574056,"src_start":573605},{"artifact":1,"gen_end":745205,"gen_start":744784,"node":374,"role":"declaration","source":0,"src_end":574391,"src_start":574058},{"artifact":1,"gen_end":755396,"gen_start":745205,"node":375,"role":"declaration","source":0,"src_end":582139,"src_start":574393},{"artifact":1,"gen_end":755984,"gen_start":755396,"node":376,"role":"declaration","source":0,"src_end":582580,"src_start":582141},{"artifact":1,"gen_end":756394,"gen_start":755984,"node":377,"role":"declaration","source":0,"src_end":582904,"src_start":582582},{"artifact":1,"gen_end":766449,"gen_start":756394,"node":378,"role":"declaration","source":0,"src_end":590538,"src_start":582906},{"artifact":1,"gen_end":767035,"gen_start":766449,"node":379,"role":"declaration","source":0,"src_end":590977,"src_start":590540},{"artifact":1,"gen_end":767431,"gen_start":767035,"node":380,"role":"declaration","source":0,"src_end":591287,"src_start":590979},{"artifact":1,"gen_end":777626,"gen_start":767431,"node":381,"role":"declaration","source":0,"src_end":599039,"src_start":591289},{"artifact":1,"gen_end":778220,"gen_start":777626,"node":382,"role":"declaration","source":0,"src_end":599486,"src_start":599041},{"artifact":1,"gen_end":778628,"gen_start":778220,"node":383,"role":"declaration","source":0,"src_end":599808,"src_start":599488},{"artifact":1,"gen_end":788671,"gen_start":778628,"node":384,"role":"declaration","source":0,"src_end":607430,"src_start":599810},{"artifact":1,"gen_end":789251,"gen_start":788671,"node":385,"role":"declaration","source":0,"src_end":607863,"src_start":607432},{"artifact":1,"gen_end":789605,"gen_start":789251,"node":386,"role":"declaration","source":0,"src_end":608139,"src_start":607865},{"artifact":1,"gen_end":799648,"gen_start":789605,"node":387,"role":"declaration","source":0,"src_end":615761,"src_start":608141},{"artifact":1,"gen_end":800228,"gen_start":799648,"node":388,"role":"declaration","source":0,"src_end":616194,"src_start":615763},{"artifact":1,"gen_end":800582,"gen_start":800228,"node":389,"role":"declaration","source":0,"src_end":616470,"src_start":616196},{"artifact":1,"gen_end":810637,"gen_start":800582,"node":390,"role":"declaration","source":0,"src_end":624104,"src_start":616472},{"artifact":1,"gen_end":811227,"gen_start":810637,"node":391,"role":"declaration","source":0,"src_end":624547,"src_start":624106},{"artifact":1,"gen_end":811600,"gen_start":811227,"node":392,"role":"declaration","source":0,"src_end":624842,"src_start":624549},{"artifact":1,"gen_end":821654,"gen_start":811600,"node":393,"role":"declaration","source":0,"src_end":632473,"src_start":624844},{"artifact":1,"gen_end":822234,"gen_start":821654,"node":394,"role":"declaration","source":0,"src_end":632906,"src_start":632475},{"artifact":1,"gen_end":822623,"gen_start":822234,"node":395,"role":"declaration","source":0,"src_end":633209,"src_start":632908},{"artifact":1,"gen_end":832818,"gen_start":822623,"node":396,"role":"declaration","source":0,"src_end":640959,"src_start":633211},{"artifact":1,"gen_end":833408,"gen_start":832818,"node":397,"role":"declaration","source":0,"src_end":641402,"src_start":640961},{"artifact":1,"gen_end":833812,"gen_start":833408,"node":398,"role":"declaration","source":0,"src_end":641720,"src_start":641404},{"artifact":1,"gen_end":843157,"gen_start":833812,"node":399,"role":"declaration","source":0,"src_end":648764,"src_start":641722},{"artifact":1,"gen_end":843719,"gen_start":843157,"node":400,"role":"declaration","source":0,"src_end":649179,"src_start":648766},{"artifact":1,"gen_end":844365,"gen_start":843719,"node":401,"role":"declaration","source":0,"src_end":649685,"src_start":649181},{"artifact":1,"gen_end":844683,"gen_start":844365,"node":402,"role":"declaration","source":0,"src_end":649923,"src_start":649687},{"artifact":1,"gen_end":855272,"gen_start":844683,"node":403,"role":"declaration","source":0,"src_end":657956,"src_start":649925},{"artifact":1,"gen_end":855677,"gen_start":855272,"node":404,"role":"declaration","source":0,"src_end":658248,"src_start":657958},{"artifact":1,"gen_end":856166,"gen_start":855677,"node":405,"role":"declaration","source":0,"src_end":658625,"src_start":658250},{"artifact":1,"gen_end":856472,"gen_start":856166,"node":406,"role":"declaration","source":0,"src_end":658861,"src_start":658627},{"artifact":1,"gen_end":870686,"gen_start":856472,"node":407,"role":"declaration","source":0,"src_end":669575,"src_start":658863},{"artifact":1,"gen_end":871130,"gen_start":870686,"node":408,"role":"declaration","source":0,"src_end":669900,"src_start":669577},{"artifact":1,"gen_end":871678,"gen_start":871130,"node":409,"role":"declaration","source":0,"src_end":670324,"src_start":669902},{"artifact":1,"gen_end":872019,"gen_start":871678,"node":410,"role":"declaration","source":0,"src_end":670591,"src_start":670326},{"artifact":1,"gen_end":872364,"gen_start":872019,"node":411,"role":"declaration","source":0,"src_end":670858,"src_start":670593},{"artifact":1,"gen_end":872709,"gen_start":872364,"node":412,"role":"declaration","source":0,"src_end":671125,"src_start":670860},{"artifact":1,"gen_end":873054,"gen_start":872709,"node":413,"role":"declaration","source":0,"src_end":671392,"src_start":671127},{"artifact":1,"gen_end":873408,"gen_start":873054,"node":414,"role":"declaration","source":0,"src_end":671670,"src_start":671394},{"artifact":1,"gen_end":873697,"gen_start":873408,"node":415,"role":"declaration","source":0,"src_end":671895,"src_start":671672},{"artifact":1,"gen_end":883735,"gen_start":873697,"node":416,"role":"declaration","source":0,"src_end":679512,"src_start":671897},{"artifact":1,"gen_end":884297,"gen_start":883735,"node":417,"role":"declaration","source":0,"src_end":679927,"src_start":679514},{"artifact":1,"gen_end":884947,"gen_start":884297,"node":418,"role":"declaration","source":0,"src_end":680437,"src_start":679929},{"artifact":1,"gen_end":885266,"gen_start":884947,"node":419,"role":"declaration","source":0,"src_end":680676,"src_start":680439},{"artifact":1,"gen_end":885281,"gen_start":885266,"node":210,"role":"declaration","source":0,"src_end":680712,"src_start":0}],"module":"GnafFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-latex-module"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-declaration"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"},{"id":348,"kind":"semantic-declaration"},{"id":349,"kind":"semantic-declaration"},{"id":350,"kind":"semantic-declaration"},{"id":351,"kind":"semantic-declaration"},{"id":352,"kind":"semantic-declaration"},{"id":353,"kind":"semantic-declaration"},{"id":354,"kind":"semantic-declaration"},{"id":355,"kind":"semantic-declaration"},{"id":356,"kind":"semantic-declaration"},{"id":357,"kind":"semantic-declaration"},{"id":358,"kind":"semantic-declaration"},{"id":359,"kind":"semantic-declaration"},{"id":360,"kind":"semantic-declaration"},{"id":361,"kind":"semantic-declaration"},{"id":362,"kind":"semantic-declaration"},{"id":363,"kind":"semantic-declaration"},{"id":364,"kind":"semantic-declaration"},{"id":365,"kind":"semantic-declaration"},{"id":366,"kind":"semantic-declaration"},{"id":367,"kind":"semantic-declaration"},{"id":368,"kind":"semantic-declaration"},{"id":369,"kind":"semantic-declaration"},{"id":370,"kind":"semantic-declaration"},{"id":371,"kind":"semantic-declaration"},{"id":372,"kind":"semantic-declaration"},{"id":373,"kind":"semantic-declaration"},{"id":374,"kind":"semantic-declaration"},{"id":375,"kind":"semantic-declaration"},{"id":376,"kind":"semantic-declaration"},{"id":377,"kind":"semantic-declaration"},{"id":378,"kind":"semantic-declaration"},{"id":379,"kind":"semantic-declaration"},{"id":380,"kind":"semantic-declaration"},{"id":381,"kind":"semantic-declaration"},{"id":382,"kind":"semantic-declaration"},{"id":383,"kind":"semantic-declaration"},{"id":384,"kind":"semantic-declaration"},{"id":385,"kind":"semantic-declaration"},{"id":386,"kind":"semantic-declaration"},{"id":387,"kind":"semantic-declaration"},{"id":388,"kind":"semantic-declaration"},{"id":389,"kind":"semantic-declaration"},{"id":390,"kind":"semantic-declaration"},{"id":391,"kind":"semantic-declaration"},{"id":392,"kind":"semantic-declaration"},{"id":393,"kind":"semantic-declaration"},{"id":394,"kind":"semantic-declaration"},{"id":395,"kind":"semantic-declaration"},{"id":396,"kind":"semantic-declaration"},{"id":397,"kind":"semantic-declaration"},{"id":398,"kind":"semantic-declaration"},{"id":399,"kind":"semantic-declaration"},{"id":400,"kind":"semantic-declaration"},{"id":401,"kind":"semantic-declaration"},{"id":402,"kind":"semantic-declaration"},{"id":403,"kind":"semantic-declaration"},{"id":404,"kind":"semantic-declaration"},{"id":405,"kind":"semantic-declaration"},{"id":406,"kind":"semantic-declaration"},{"id":407,"kind":"semantic-declaration"},{"id":408,"kind":"semantic-declaration"},{"id":409,"kind":"semantic-declaration"},{"id":410,"kind":"semantic-declaration"},{"id":411,"kind":"semantic-declaration"},{"id":412,"kind":"semantic-declaration"},{"id":413,"kind":"semantic-declaration"},{"id":414,"kind":"semantic-declaration"},{"id":415,"kind":"semantic-declaration"},{"id":416,"kind":"semantic-declaration"},{"id":417,"kind":"semantic-declaration"},{"id":418,"kind":"semantic-declaration"},{"id":419,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/GnafFixtures.lex.tex","sha256":"e7f06e087d0ec40b8dd61f2fe1c51258ec55d93f5e5e16938c27598661e8d913"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GnafFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GnafFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":327,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":0,"gen_end":10109,"gen_start":327,"node":1,"role":"declaration","source":0,"src_end":7817,"src_start":200},{"artifact":0,"gen_end":10564,"gen_start":10109,"node":2,"role":"declaration","source":0,"src_end":8234,"src_start":7819},{"artifact":0,"gen_end":11066,"gen_start":10564,"node":3,"role":"declaration","source":0,"src_end":8746,"src_start":8236},{"artifact":0,"gen_end":11237,"gen_start":11066,"node":4,"role":"declaration","source":0,"src_end":8987,"src_start":8748},{"artifact":0,"gen_end":21021,"gen_start":11237,"node":5,"role":"declaration","source":0,"src_end":16608,"src_start":8989},{"artifact":0,"gen_end":21482,"gen_start":21021,"node":6,"role":"declaration","source":0,"src_end":17031,"src_start":16610},{"artifact":0,"gen_end":21990,"gen_start":21482,"node":7,"role":"declaration","source":0,"src_end":17549,"src_start":17033},{"artifact":0,"gen_end":22167,"gen_start":21990,"node":8,"role":"declaration","source":0,"src_end":17796,"src_start":17551},{"artifact":0,"gen_end":35192,"gen_start":22167,"node":9,"role":"declaration","source":0,"src_end":27873,"src_start":17798},{"artifact":0,"gen_end":35950,"gen_start":35192,"node":10,"role":"declaration","source":0,"src_end":28537,"src_start":27875},{"artifact":0,"gen_end":36780,"gen_start":35950,"node":11,"role":"declaration","source":0,"src_end":29329,"src_start":28539},{"artifact":0,"gen_end":36948,"gen_start":36780,"node":12,"role":"declaration","source":0,"src_end":29569,"src_start":29331},{"artifact":0,"gen_end":57064,"gen_start":36948,"node":13,"role":"declaration","source":0,"src_end":45993,"src_start":29571},{"artifact":0,"gen_end":57529,"gen_start":57064,"node":14,"role":"declaration","source":0,"src_end":46420,"src_start":45995},{"artifact":0,"gen_end":58016,"gen_start":57529,"node":15,"role":"declaration","source":0,"src_end":46929,"src_start":46422},{"artifact":0,"gen_end":58168,"gen_start":58016,"node":16,"role":"declaration","source":0,"src_end":47161,"src_start":46931},{"artifact":0,"gen_end":68390,"gen_start":58168,"node":17,"role":"declaration","source":0,"src_end":55137,"src_start":47163},{"artifact":0,"gen_end":68723,"gen_start":68390,"node":18,"role":"declaration","source":0,"src_end":55460,"src_start":55139},{"artifact":0,"gen_end":69119,"gen_start":68723,"node":19,"role":"declaration","source":0,"src_end":55882,"src_start":55462},{"artifact":0,"gen_end":69297,"gen_start":69119,"node":20,"role":"declaration","source":0,"src_end":56130,"src_start":55884},{"artifact":0,"gen_end":79087,"gen_start":69297,"node":21,"role":"declaration","source":0,"src_end":63757,"src_start":56132},{"artifact":0,"gen_end":79554,"gen_start":79087,"node":22,"role":"declaration","source":0,"src_end":64186,"src_start":63759},{"artifact":0,"gen_end":80068,"gen_start":79554,"node":23,"role":"declaration","source":0,"src_end":64710,"src_start":64188},{"artifact":0,"gen_end":80254,"gen_start":80068,"node":24,"role":"declaration","source":0,"src_end":64970,"src_start":64712},{"artifact":0,"gen_end":100375,"gen_start":80254,"node":25,"role":"declaration","source":0,"src_end":81399,"src_start":64972},{"artifact":0,"gen_end":100846,"gen_start":100375,"node":26,"role":"declaration","source":0,"src_end":81832,"src_start":81401},{"artifact":0,"gen_end":101339,"gen_start":100846,"node":27,"role":"declaration","source":0,"src_end":82347,"src_start":81834},{"artifact":0,"gen_end":101497,"gen_start":101339,"node":28,"role":"declaration","source":0,"src_end":82585,"src_start":82349},{"artifact":0,"gen_end":111285,"gen_start":101497,"node":29,"role":"declaration","source":0,"src_end":90210,"src_start":82587},{"artifact":0,"gen_end":111754,"gen_start":111285,"node":30,"role":"declaration","source":0,"src_end":90641,"src_start":90212},{"artifact":0,"gen_end":112270,"gen_start":111754,"node":31,"role":"declaration","source":0,"src_end":91167,"src_start":90643},{"artifact":0,"gen_end":112458,"gen_start":112270,"node":32,"role":"declaration","source":0,"src_end":91429,"src_start":91169},{"artifact":0,"gen_end":125487,"gen_start":112458,"node":33,"role":"declaration","source":0,"src_end":101510,"src_start":91431},{"artifact":0,"gen_end":126249,"gen_start":125487,"node":34,"role":"declaration","source":0,"src_end":102178,"src_start":101512},{"artifact":0,"gen_end":127083,"gen_start":126249,"node":35,"role":"declaration","source":0,"src_end":102974,"src_start":102180},{"artifact":0,"gen_end":127258,"gen_start":127083,"node":36,"role":"declaration","source":0,"src_end":103225,"src_start":102976},{"artifact":0,"gen_end":135083,"gen_start":127258,"node":37,"role":"declaration","source":0,"src_end":109365,"src_start":103227},{"artifact":0,"gen_end":135558,"gen_start":135083,"node":38,"role":"declaration","source":0,"src_end":109802,"src_start":109367},{"artifact":0,"gen_end":136059,"gen_start":135558,"node":39,"role":"declaration","source":0,"src_end":110325,"src_start":109804},{"artifact":0,"gen_end":136250,"gen_start":136059,"node":40,"role":"declaration","source":0,"src_end":110586,"src_start":110327},{"artifact":0,"gen_end":142223,"gen_start":136250,"node":41,"role":"declaration","source":0,"src_end":115319,"src_start":110588},{"artifact":0,"gen_end":142427,"gen_start":142223,"node":42,"role":"declaration","source":0,"src_end":115531,"src_start":115321},{"artifact":0,"gen_end":142650,"gen_start":142427,"node":43,"role":"declaration","source":0,"src_end":115808,"src_start":115533},{"artifact":0,"gen_end":142800,"gen_start":142650,"node":44,"role":"declaration","source":0,"src_end":116038,"src_start":115810},{"artifact":0,"gen_end":152176,"gen_start":142800,"node":45,"role":"declaration","source":0,"src_end":123350,"src_start":116040},{"artifact":0,"gen_end":152649,"gen_start":152176,"node":46,"role":"declaration","source":0,"src_end":123785,"src_start":123352},{"artifact":0,"gen_end":153166,"gen_start":152649,"node":47,"role":"declaration","source":0,"src_end":124312,"src_start":123787},{"artifact":0,"gen_end":153354,"gen_start":153166,"node":48,"role":"declaration","source":0,"src_end":124570,"src_start":124314},{"artifact":0,"gen_end":162498,"gen_start":153354,"node":49,"role":"declaration","source":0,"src_end":131650,"src_start":124572},{"artifact":0,"gen_end":162973,"gen_start":162498,"node":50,"role":"declaration","source":0,"src_end":132087,"src_start":131652},{"artifact":0,"gen_end":163492,"gen_start":162973,"node":51,"role":"declaration","source":0,"src_end":132616,"src_start":132089},{"artifact":0,"gen_end":163682,"gen_start":163492,"node":52,"role":"declaration","source":0,"src_end":132876,"src_start":132618},{"artifact":0,"gen_end":183799,"gen_start":163682,"node":53,"role":"declaration","source":0,"src_end":149301,"src_start":132878},{"artifact":0,"gen_end":184268,"gen_start":183799,"node":54,"role":"declaration","source":0,"src_end":149732,"src_start":149303},{"artifact":0,"gen_end":184759,"gen_start":184268,"node":55,"role":"declaration","source":0,"src_end":150245,"src_start":149734},{"artifact":0,"gen_end":184915,"gen_start":184759,"node":56,"role":"declaration","source":0,"src_end":150481,"src_start":150247},{"artifact":0,"gen_end":197940,"gen_start":184915,"node":57,"role":"declaration","source":0,"src_end":160558,"src_start":150483},{"artifact":0,"gen_end":198700,"gen_start":197940,"node":58,"role":"declaration","source":0,"src_end":161224,"src_start":160560},{"artifact":0,"gen_end":199532,"gen_start":198700,"node":59,"role":"declaration","source":0,"src_end":162018,"src_start":161226},{"artifact":0,"gen_end":199702,"gen_start":199532,"node":60,"role":"declaration","source":0,"src_end":162260,"src_start":162020},{"artifact":0,"gen_end":209678,"gen_start":199702,"node":61,"role":"declaration","source":0,"src_end":170047,"src_start":162262},{"artifact":0,"gen_end":210141,"gen_start":209678,"node":62,"role":"declaration","source":0,"src_end":170472,"src_start":170049},{"artifact":0,"gen_end":210651,"gen_start":210141,"node":63,"role":"declaration","source":0,"src_end":170992,"src_start":170474},{"artifact":0,"gen_end":210830,"gen_start":210651,"node":64,"role":"declaration","source":0,"src_end":171241,"src_start":170994},{"artifact":0,"gen_end":220977,"gen_start":210830,"node":65,"role":"declaration","source":0,"src_end":179187,"src_start":171243},{"artifact":0,"gen_end":221446,"gen_start":220977,"node":66,"role":"declaration","source":0,"src_end":179618,"src_start":179189},{"artifact":0,"gen_end":221962,"gen_start":221446,"node":67,"role":"declaration","source":0,"src_end":180144,"src_start":179620},{"artifact":0,"gen_end":222147,"gen_start":221962,"node":68,"role":"declaration","source":0,"src_end":180399,"src_start":180146},{"artifact":0,"gen_end":232296,"gen_start":222147,"node":69,"role":"declaration","source":0,"src_end":188347,"src_start":180401},{"artifact":0,"gen_end":232767,"gen_start":232296,"node":70,"role":"declaration","source":0,"src_end":188780,"src_start":188349},{"artifact":0,"gen_end":233285,"gen_start":232767,"node":71,"role":"declaration","source":0,"src_end":189308,"src_start":188782},{"artifact":0,"gen_end":233472,"gen_start":233285,"node":72,"role":"declaration","source":0,"src_end":189565,"src_start":189310},{"artifact":0,"gen_end":304190,"gen_start":233472,"node":73,"role":"declaration","source":0,"src_end":244998,"src_start":189567},{"artifact":0,"gen_end":304474,"gen_start":304190,"node":74,"role":"declaration","source":0,"src_end":245278,"src_start":245000},{"artifact":0,"gen_end":304816,"gen_start":304474,"node":75,"role":"declaration","source":0,"src_end":245654,"src_start":245280},{"artifact":0,"gen_end":304990,"gen_start":304816,"node":76,"role":"declaration","source":0,"src_end":245898,"src_start":245656},{"artifact":0,"gen_end":375712,"gen_start":304990,"node":77,"role":"declaration","source":0,"src_end":301335,"src_start":245900},{"artifact":0,"gen_end":376000,"gen_start":375712,"node":78,"role":"declaration","source":0,"src_end":301619,"src_start":301337},{"artifact":0,"gen_end":376346,"gen_start":376000,"node":79,"role":"declaration","source":0,"src_end":301999,"src_start":301621},{"artifact":0,"gen_end":376519,"gen_start":376346,"node":80,"role":"declaration","source":0,"src_end":302244,"src_start":302001},{"artifact":0,"gen_end":386305,"gen_start":376519,"node":81,"role":"declaration","source":0,"src_end":309867,"src_start":302246},{"artifact":0,"gen_end":386772,"gen_start":386305,"node":82,"role":"declaration","source":0,"src_end":310296,"src_start":309869},{"artifact":0,"gen_end":386970,"gen_start":386772,"node":83,"role":"declaration","source":0,"src_end":310566,"src_start":310298},{"artifact":0,"gen_end":391377,"gen_start":386970,"node":84,"role":"declaration","source":0,"src_end":314109,"src_start":310568},{"artifact":0,"gen_end":391542,"gen_start":391377,"node":85,"role":"declaration","source":0,"src_end":314288,"src_start":314111},{"artifact":0,"gen_end":391740,"gen_start":391542,"node":86,"role":"declaration","source":0,"src_end":314558,"src_start":314290},{"artifact":0,"gen_end":401534,"gen_start":391740,"node":87,"role":"declaration","source":0,"src_end":322189,"src_start":314560},{"artifact":0,"gen_end":402013,"gen_start":401534,"node":88,"role":"declaration","source":0,"src_end":322630,"src_start":322191},{"artifact":0,"gen_end":402223,"gen_start":402013,"node":89,"role":"declaration","source":0,"src_end":322912,"src_start":322632},{"artifact":0,"gen_end":412143,"gen_start":402223,"node":90,"role":"declaration","source":0,"src_end":330649,"src_start":322914},{"artifact":0,"gen_end":412608,"gen_start":412143,"node":91,"role":"declaration","source":0,"src_end":331076,"src_start":330651},{"artifact":0,"gen_end":412854,"gen_start":412608,"node":92,"role":"declaration","source":0,"src_end":331386,"src_start":331078},{"artifact":0,"gen_end":422654,"gen_start":412854,"node":93,"role":"declaration","source":0,"src_end":339021,"src_start":331388},{"artifact":0,"gen_end":423133,"gen_start":422654,"node":94,"role":"declaration","source":0,"src_end":339462,"src_start":339023},{"artifact":0,"gen_end":423380,"gen_start":423133,"node":95,"role":"declaration","source":0,"src_end":339773,"src_start":339464},{"artifact":0,"gen_end":427829,"gen_start":423380,"node":96,"role":"declaration","source":0,"src_end":343352,"src_start":339775},{"artifact":0,"gen_end":428002,"gen_start":427829,"node":97,"role":"declaration","source":0,"src_end":343539,"src_start":343354},{"artifact":0,"gen_end":428212,"gen_start":428002,"node":98,"role":"declaration","source":0,"src_end":343821,"src_start":343541},{"artifact":0,"gen_end":438129,"gen_start":428212,"node":99,"role":"declaration","source":0,"src_end":351555,"src_start":343823},{"artifact":0,"gen_end":438598,"gen_start":438129,"node":100,"role":"declaration","source":0,"src_end":351986,"src_start":351557},{"artifact":0,"gen_end":438840,"gen_start":438598,"node":101,"role":"declaration","source":0,"src_end":352292,"src_start":351988},{"artifact":0,"gen_end":447563,"gen_start":438840,"node":102,"role":"declaration","source":0,"src_end":359050,"src_start":352294},{"artifact":0,"gen_end":448024,"gen_start":447563,"node":103,"role":"declaration","source":0,"src_end":359473,"src_start":359052},{"artifact":0,"gen_end":448213,"gen_start":448024,"node":104,"role":"declaration","source":0,"src_end":359734,"src_start":359475},{"artifact":0,"gen_end":458000,"gen_start":448213,"node":105,"role":"declaration","source":0,"src_end":367358,"src_start":359736},{"artifact":0,"gen_end":458469,"gen_start":458000,"node":106,"role":"declaration","source":0,"src_end":367789,"src_start":367360},{"artifact":0,"gen_end":458709,"gen_start":458469,"node":107,"role":"declaration","source":0,"src_end":368093,"src_start":367791},{"artifact":0,"gen_end":468648,"gen_start":458709,"node":108,"role":"declaration","source":0,"src_end":375849,"src_start":368095},{"artifact":0,"gen_end":469153,"gen_start":468648,"node":109,"role":"declaration","source":0,"src_end":376316,"src_start":375851},{"artifact":0,"gen_end":469439,"gen_start":469153,"node":110,"role":"declaration","source":0,"src_end":376666,"src_start":376318},{"artifact":0,"gen_end":479242,"gen_start":469439,"node":111,"role":"declaration","source":0,"src_end":384302,"src_start":376668},{"artifact":0,"gen_end":479721,"gen_start":479242,"node":112,"role":"declaration","source":0,"src_end":384743,"src_start":384304},{"artifact":0,"gen_end":479933,"gen_start":479721,"node":113,"role":"declaration","source":0,"src_end":385027,"src_start":384745},{"artifact":0,"gen_end":484353,"gen_start":479933,"node":114,"role":"declaration","source":0,"src_end":388583,"src_start":385029},{"artifact":0,"gen_end":484530,"gen_start":484353,"node":115,"role":"declaration","source":0,"src_end":388774,"src_start":388585},{"artifact":0,"gen_end":484746,"gen_start":484530,"node":116,"role":"declaration","source":0,"src_end":389062,"src_start":388776},{"artifact":0,"gen_end":494530,"gen_start":484746,"node":117,"role":"declaration","source":0,"src_end":396683,"src_start":389064},{"artifact":0,"gen_end":495007,"gen_start":494530,"node":118,"role":"declaration","source":0,"src_end":397122,"src_start":396685},{"artifact":0,"gen_end":495220,"gen_start":495007,"node":119,"role":"declaration","source":0,"src_end":397407,"src_start":397124},{"artifact":0,"gen_end":505013,"gen_start":495220,"node":120,"role":"declaration","source":0,"src_end":405037,"src_start":397409},{"artifact":0,"gen_end":505494,"gen_start":505013,"node":121,"role":"declaration","source":0,"src_end":405480,"src_start":405039},{"artifact":0,"gen_end":505713,"gen_start":505494,"node":122,"role":"declaration","source":0,"src_end":405771,"src_start":405482},{"artifact":0,"gen_end":510139,"gen_start":505713,"node":123,"role":"declaration","source":0,"src_end":409333,"src_start":405773},{"artifact":0,"gen_end":510324,"gen_start":510139,"node":124,"role":"declaration","source":0,"src_end":409532,"src_start":409335},{"artifact":0,"gen_end":510552,"gen_start":510324,"node":125,"role":"declaration","source":0,"src_end":409832,"src_start":409534},{"artifact":0,"gen_end":520418,"gen_start":510552,"node":126,"role":"declaration","source":0,"src_end":417529,"src_start":409834},{"artifact":0,"gen_end":520915,"gen_start":520418,"node":127,"role":"declaration","source":0,"src_end":417988,"src_start":417531},{"artifact":0,"gen_end":521145,"gen_start":520915,"node":128,"role":"declaration","source":0,"src_end":418290,"src_start":417990},{"artifact":0,"gen_end":531059,"gen_start":521145,"node":129,"role":"declaration","source":0,"src_end":426021,"src_start":418292},{"artifact":0,"gen_end":531518,"gen_start":531059,"node":130,"role":"declaration","source":0,"src_end":426442,"src_start":426023},{"artifact":0,"gen_end":531755,"gen_start":531518,"node":131,"role":"declaration","source":0,"src_end":426743,"src_start":426444},{"artifact":0,"gen_end":551125,"gen_start":531755,"node":132,"role":"declaration","source":0,"src_end":442012,"src_start":426745},{"artifact":0,"gen_end":551316,"gen_start":551125,"node":133,"role":"declaration","source":0,"src_end":442217,"src_start":442014},{"artifact":0,"gen_end":551544,"gen_start":551316,"node":134,"role":"declaration","source":0,"src_end":442517,"src_start":442219},{"artifact":0,"gen_end":622271,"gen_start":551544,"node":135,"role":"declaration","source":0,"src_end":497959,"src_start":442519},{"artifact":0,"gen_end":622575,"gen_start":622271,"node":136,"role":"declaration","source":0,"src_end":498259,"src_start":497961},{"artifact":0,"gen_end":622821,"gen_start":622575,"node":137,"role":"declaration","source":0,"src_end":498569,"src_start":498261},{"artifact":0,"gen_end":632629,"gen_start":622821,"node":138,"role":"declaration","source":0,"src_end":506214,"src_start":498571},{"artifact":0,"gen_end":633114,"gen_start":632629,"node":139,"role":"declaration","source":0,"src_end":506661,"src_start":506216},{"artifact":0,"gen_end":633326,"gen_start":633114,"node":140,"role":"declaration","source":0,"src_end":506945,"src_start":506663},{"artifact":0,"gen_end":643112,"gen_start":633326,"node":141,"role":"declaration","source":0,"src_end":514568,"src_start":506947},{"artifact":0,"gen_end":643583,"gen_start":643112,"node":142,"role":"declaration","source":0,"src_end":515001,"src_start":514570},{"artifact":0,"gen_end":643785,"gen_start":643583,"node":143,"role":"declaration","source":0,"src_end":515275,"src_start":515003},{"artifact":0,"gen_end":653581,"gen_start":643785,"node":144,"role":"declaration","source":0,"src_end":522908,"src_start":515277},{"artifact":0,"gen_end":654066,"gen_start":653581,"node":145,"role":"declaration","source":0,"src_end":523355,"src_start":522910},{"artifact":0,"gen_end":654295,"gen_start":654066,"node":146,"role":"declaration","source":0,"src_end":523656,"src_start":523357},{"artifact":0,"gen_end":664209,"gen_start":654295,"node":147,"role":"declaration","source":0,"src_end":531387,"src_start":523658},{"artifact":0,"gen_end":664668,"gen_start":664209,"node":148,"role":"declaration","source":0,"src_end":531808,"src_start":531389},{"artifact":0,"gen_end":664905,"gen_start":664668,"node":149,"role":"declaration","source":0,"src_end":532109,"src_start":531810},{"artifact":0,"gen_end":674705,"gen_start":664905,"node":150,"role":"declaration","source":0,"src_end":539746,"src_start":532111},{"artifact":0,"gen_end":675198,"gen_start":674705,"node":151,"role":"declaration","source":0,"src_end":540201,"src_start":539748},{"artifact":0,"gen_end":675435,"gen_start":675198,"node":152,"role":"declaration","source":0,"src_end":540510,"src_start":540203},{"artifact":0,"gen_end":685352,"gen_start":675435,"node":153,"role":"declaration","source":0,"src_end":548244,"src_start":540512},{"artifact":0,"gen_end":685825,"gen_start":685352,"node":154,"role":"declaration","source":0,"src_end":548679,"src_start":548246},{"artifact":0,"gen_end":686064,"gen_start":685825,"node":155,"role":"declaration","source":0,"src_end":548982,"src_start":548681},{"artifact":0,"gen_end":696163,"gen_start":686064,"node":156,"role":"declaration","source":0,"src_end":556882,"src_start":548984},{"artifact":0,"gen_end":696644,"gen_start":696163,"node":157,"role":"declaration","source":0,"src_end":557325,"src_start":556884},{"artifact":0,"gen_end":696902,"gen_start":696644,"node":158,"role":"declaration","source":0,"src_end":557647,"src_start":557327},{"artifact":0,"gen_end":706565,"gen_start":696902,"node":159,"role":"declaration","source":0,"src_end":565167,"src_start":557649},{"artifact":0,"gen_end":707042,"gen_start":706565,"node":160,"role":"declaration","source":0,"src_end":565606,"src_start":565169},{"artifact":0,"gen_end":707294,"gen_start":707042,"node":161,"role":"declaration","source":0,"src_end":565922,"src_start":565608},{"artifact":0,"gen_end":717142,"gen_start":707294,"node":162,"role":"declaration","source":0,"src_end":573603,"src_start":565924},{"artifact":0,"gen_end":717633,"gen_start":717142,"node":163,"role":"declaration","source":0,"src_end":574056,"src_start":573605},{"artifact":0,"gen_end":717904,"gen_start":717633,"node":164,"role":"declaration","source":0,"src_end":574391,"src_start":574058},{"artifact":0,"gen_end":727835,"gen_start":717904,"node":165,"role":"declaration","source":0,"src_end":582139,"src_start":574393},{"artifact":0,"gen_end":728314,"gen_start":727835,"node":166,"role":"declaration","source":0,"src_end":582580,"src_start":582141},{"artifact":0,"gen_end":728574,"gen_start":728314,"node":167,"role":"declaration","source":0,"src_end":582904,"src_start":582582},{"artifact":0,"gen_end":738371,"gen_start":728574,"node":168,"role":"declaration","source":0,"src_end":590538,"src_start":582906},{"artifact":0,"gen_end":738848,"gen_start":738371,"node":169,"role":"declaration","source":0,"src_end":590977,"src_start":590540},{"artifact":0,"gen_end":739094,"gen_start":738848,"node":170,"role":"declaration","source":0,"src_end":591287,"src_start":590979},{"artifact":0,"gen_end":749029,"gen_start":739094,"node":171,"role":"declaration","source":0,"src_end":599039,"src_start":591289},{"artifact":0,"gen_end":749514,"gen_start":749029,"node":172,"role":"declaration","source":0,"src_end":599486,"src_start":599041},{"artifact":0,"gen_end":749772,"gen_start":749514,"node":173,"role":"declaration","source":0,"src_end":599808,"src_start":599488},{"artifact":0,"gen_end":759557,"gen_start":749772,"node":174,"role":"declaration","source":0,"src_end":607430,"src_start":599810},{"artifact":0,"gen_end":760028,"gen_start":759557,"node":175,"role":"declaration","source":0,"src_end":607863,"src_start":607432},{"artifact":0,"gen_end":760232,"gen_start":760028,"node":176,"role":"declaration","source":0,"src_end":608139,"src_start":607865},{"artifact":0,"gen_end":770017,"gen_start":760232,"node":177,"role":"declaration","source":0,"src_end":615761,"src_start":608141},{"artifact":0,"gen_end":770488,"gen_start":770017,"node":178,"role":"declaration","source":0,"src_end":616194,"src_start":615763},{"artifact":0,"gen_end":770692,"gen_start":770488,"node":179,"role":"declaration","source":0,"src_end":616470,"src_start":616196},{"artifact":0,"gen_end":780489,"gen_start":770692,"node":180,"role":"declaration","source":0,"src_end":624104,"src_start":616472},{"artifact":0,"gen_end":780970,"gen_start":780489,"node":181,"role":"declaration","source":0,"src_end":624547,"src_start":624106},{"artifact":0,"gen_end":781193,"gen_start":780970,"node":182,"role":"declaration","source":0,"src_end":624842,"src_start":624549},{"artifact":0,"gen_end":790989,"gen_start":781193,"node":183,"role":"declaration","source":0,"src_end":632473,"src_start":624844},{"artifact":0,"gen_end":791460,"gen_start":790989,"node":184,"role":"declaration","source":0,"src_end":632906,"src_start":632475},{"artifact":0,"gen_end":791699,"gen_start":791460,"node":185,"role":"declaration","source":0,"src_end":633209,"src_start":632908},{"artifact":0,"gen_end":801634,"gen_start":791699,"node":186,"role":"declaration","source":0,"src_end":640959,"src_start":633211},{"artifact":0,"gen_end":802115,"gen_start":801634,"node":187,"role":"declaration","source":0,"src_end":641402,"src_start":640961},{"artifact":0,"gen_end":802369,"gen_start":802115,"node":188,"role":"declaration","source":0,"src_end":641720,"src_start":641404},{"artifact":0,"gen_end":811456,"gen_start":802369,"node":189,"role":"declaration","source":0,"src_end":648764,"src_start":641722},{"artifact":0,"gen_end":811909,"gen_start":811456,"node":190,"role":"declaration","source":0,"src_end":649179,"src_start":648766},{"artifact":0,"gen_end":812405,"gen_start":811909,"node":191,"role":"declaration","source":0,"src_end":649685,"src_start":649181},{"artifact":0,"gen_end":812573,"gen_start":812405,"node":192,"role":"declaration","source":0,"src_end":649923,"src_start":649687},{"artifact":0,"gen_end":822900,"gen_start":812573,"node":193,"role":"declaration","source":0,"src_end":657956,"src_start":649925},{"artifact":0,"gen_end":823196,"gen_start":822900,"node":194,"role":"declaration","source":0,"src_end":658248,"src_start":657958},{"artifact":0,"gen_end":823535,"gen_start":823196,"node":195,"role":"declaration","source":0,"src_end":658625,"src_start":658250},{"artifact":0,"gen_end":823691,"gen_start":823535,"node":196,"role":"declaration","source":0,"src_end":658861,"src_start":658627},{"artifact":0,"gen_end":837567,"gen_start":823691,"node":197,"role":"declaration","source":0,"src_end":669575,"src_start":658863},{"artifact":0,"gen_end":837902,"gen_start":837567,"node":198,"role":"declaration","source":0,"src_end":669900,"src_start":669577},{"artifact":0,"gen_end":838300,"gen_start":837902,"node":199,"role":"declaration","source":0,"src_end":670324,"src_start":669902},{"artifact":0,"gen_end":838491,"gen_start":838300,"node":200,"role":"declaration","source":0,"src_end":670591,"src_start":670326},{"artifact":0,"gen_end":838686,"gen_start":838491,"node":201,"role":"declaration","source":0,"src_end":670858,"src_start":670593},{"artifact":0,"gen_end":838881,"gen_start":838686,"node":202,"role":"declaration","source":0,"src_end":671125,"src_start":670860},{"artifact":0,"gen_end":839076,"gen_start":838881,"node":203,"role":"declaration","source":0,"src_end":671392,"src_start":671127},{"artifact":0,"gen_end":839280,"gen_start":839076,"node":204,"role":"declaration","source":0,"src_end":671670,"src_start":671394},{"artifact":0,"gen_end":839419,"gen_start":839280,"node":205,"role":"declaration","source":0,"src_end":671895,"src_start":671672},{"artifact":0,"gen_end":849199,"gen_start":839419,"node":206,"role":"declaration","source":0,"src_end":679512,"src_start":671897},{"artifact":0,"gen_end":849652,"gen_start":849199,"node":207,"role":"declaration","source":0,"src_end":679927,"src_start":679514},{"artifact":0,"gen_end":850152,"gen_start":849652,"node":208,"role":"declaration","source":0,"src_end":680437,"src_start":679929},{"artifact":0,"gen_end":850321,"gen_start":850152,"node":209,"role":"declaration","source":0,"src_end":680676,"src_start":680439},{"artifact":0,"gen_end":850353,"gen_start":850321,"node":0,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":210,"role":"declaration","source":0,"src_end":680712,"src_start":0},{"artifact":1,"gen_end":10174,"gen_start":134,"node":211,"role":"declaration","source":0,"src_end":7817,"src_start":200},{"artifact":1,"gen_end":10738,"gen_start":10174,"node":212,"role":"declaration","source":0,"src_end":8234,"src_start":7819},{"artifact":1,"gen_end":11390,"gen_start":10738,"node":213,"role":"declaration","source":0,"src_end":8746,"src_start":8236},{"artifact":1,"gen_end":11711,"gen_start":11390,"node":214,"role":"declaration","source":0,"src_end":8987,"src_start":8748},{"artifact":1,"gen_end":21753,"gen_start":11711,"node":215,"role":"declaration","source":0,"src_end":16608,"src_start":8989},{"artifact":1,"gen_end":22323,"gen_start":21753,"node":216,"role":"declaration","source":0,"src_end":17031,"src_start":16610},{"artifact":1,"gen_end":22981,"gen_start":22323,"node":217,"role":"declaration","source":0,"src_end":17549,"src_start":17033},{"artifact":1,"gen_end":23308,"gen_start":22981,"node":218,"role":"declaration","source":0,"src_end":17796,"src_start":17551},{"artifact":1,"gen_end":36619,"gen_start":23308,"node":219,"role":"declaration","source":0,"src_end":27873,"src_start":17798},{"artifact":1,"gen_end":37486,"gen_start":36619,"node":220,"role":"declaration","source":0,"src_end":28537,"src_start":27875},{"artifact":1,"gen_end":38466,"gen_start":37486,"node":221,"role":"declaration","source":0,"src_end":29329,"src_start":28539},{"artifact":1,"gen_end":38784,"gen_start":38466,"node":222,"role":"declaration","source":0,"src_end":29569,"src_start":29331},{"artifact":1,"gen_end":59158,"gen_start":38784,"node":223,"role":"declaration","source":0,"src_end":45993,"src_start":29571},{"artifact":1,"gen_end":59732,"gen_start":59158,"node":224,"role":"declaration","source":0,"src_end":46420,"src_start":45995},{"artifact":1,"gen_end":60369,"gen_start":59732,"node":225,"role":"declaration","source":0,"src_end":46929,"src_start":46422},{"artifact":1,"gen_end":60671,"gen_start":60369,"node":226,"role":"declaration","source":0,"src_end":47161,"src_start":46931},{"artifact":1,"gen_end":71183,"gen_start":60671,"node":227,"role":"declaration","source":0,"src_end":55137,"src_start":47163},{"artifact":1,"gen_end":71625,"gen_start":71183,"node":228,"role":"declaration","source":0,"src_end":55460,"src_start":55139},{"artifact":1,"gen_end":72171,"gen_start":71625,"node":229,"role":"declaration","source":0,"src_end":55882,"src_start":55462},{"artifact":1,"gen_end":72499,"gen_start":72171,"node":230,"role":"declaration","source":0,"src_end":56130,"src_start":55884},{"artifact":1,"gen_end":82547,"gen_start":72499,"node":231,"role":"declaration","source":0,"src_end":63757,"src_start":56132},{"artifact":1,"gen_end":83123,"gen_start":82547,"node":232,"role":"declaration","source":0,"src_end":64186,"src_start":63759},{"artifact":1,"gen_end":83787,"gen_start":83123,"node":233,"role":"declaration","source":0,"src_end":64710,"src_start":64188},{"artifact":1,"gen_end":84123,"gen_start":83787,"node":234,"role":"declaration","source":0,"src_end":64970,"src_start":64712},{"artifact":1,"gen_end":104502,"gen_start":84123,"node":235,"role":"declaration","source":0,"src_end":81399,"src_start":64972},{"artifact":1,"gen_end":105082,"gen_start":104502,"node":236,"role":"declaration","source":0,"src_end":81832,"src_start":81401},{"artifact":1,"gen_end":105725,"gen_start":105082,"node":237,"role":"declaration","source":0,"src_end":82347,"src_start":81834},{"artifact":1,"gen_end":106033,"gen_start":105725,"node":238,"role":"declaration","source":0,"src_end":82585,"src_start":82349},{"artifact":1,"gen_end":116079,"gen_start":106033,"node":239,"role":"declaration","source":0,"src_end":90210,"src_start":82587},{"artifact":1,"gen_end":116657,"gen_start":116079,"node":240,"role":"declaration","source":0,"src_end":90641,"src_start":90212},{"artifact":1,"gen_end":117323,"gen_start":116657,"node":241,"role":"declaration","source":0,"src_end":91167,"src_start":90643},{"artifact":1,"gen_end":117661,"gen_start":117323,"node":242,"role":"declaration","source":0,"src_end":91429,"src_start":91169},{"artifact":1,"gen_end":130976,"gen_start":117661,"node":243,"role":"declaration","source":0,"src_end":101510,"src_start":91431},{"artifact":1,"gen_end":131847,"gen_start":130976,"node":244,"role":"declaration","source":0,"src_end":102178,"src_start":101512},{"artifact":1,"gen_end":132831,"gen_start":131847,"node":245,"role":"declaration","source":0,"src_end":102974,"src_start":102180},{"artifact":1,"gen_end":133156,"gen_start":132831,"node":246,"role":"declaration","source":0,"src_end":103225,"src_start":102976},{"artifact":1,"gen_end":141227,"gen_start":133156,"node":247,"role":"declaration","source":0,"src_end":109365,"src_start":103227},{"artifact":1,"gen_end":141811,"gen_start":141227,"node":248,"role":"declaration","source":0,"src_end":109802,"src_start":109367},{"artifact":1,"gen_end":142462,"gen_start":141811,"node":249,"role":"declaration","source":0,"src_end":110325,"src_start":109804},{"artifact":1,"gen_end":142803,"gen_start":142462,"node":250,"role":"declaration","source":0,"src_end":110586,"src_start":110327},{"artifact":1,"gen_end":148994,"gen_start":142803,"node":251,"role":"declaration","source":0,"src_end":115319,"src_start":110588},{"artifact":1,"gen_end":149307,"gen_start":148994,"node":252,"role":"declaration","source":0,"src_end":115531,"src_start":115321},{"artifact":1,"gen_end":149680,"gen_start":149307,"node":253,"role":"declaration","source":0,"src_end":115808,"src_start":115533},{"artifact":1,"gen_end":149980,"gen_start":149680,"node":254,"role":"declaration","source":0,"src_end":116038,"src_start":115810},{"artifact":1,"gen_end":159614,"gen_start":149980,"node":255,"role":"declaration","source":0,"src_end":123350,"src_start":116040},{"artifact":1,"gen_end":160196,"gen_start":159614,"node":256,"role":"declaration","source":0,"src_end":123785,"src_start":123352},{"artifact":1,"gen_end":160863,"gen_start":160196,"node":257,"role":"declaration","source":0,"src_end":124312,"src_start":123787},{"artifact":1,"gen_end":161201,"gen_start":160863,"node":258,"role":"declaration","source":0,"src_end":124570,"src_start":124314},{"artifact":1,"gen_end":170603,"gen_start":161201,"node":259,"role":"declaration","source":0,"src_end":131650,"src_start":124572},{"artifact":1,"gen_end":171187,"gen_start":170603,"node":260,"role":"declaration","source":0,"src_end":132087,"src_start":131652},{"artifact":1,"gen_end":171856,"gen_start":171187,"node":261,"role":"declaration","source":0,"src_end":132616,"src_start":132089},{"artifact":1,"gen_end":172196,"gen_start":171856,"node":262,"role":"declaration","source":0,"src_end":132876,"src_start":132618},{"artifact":1,"gen_end":192571,"gen_start":172196,"node":263,"role":"declaration","source":0,"src_end":149301,"src_start":132878},{"artifact":1,"gen_end":193149,"gen_start":192571,"node":264,"role":"declaration","source":0,"src_end":149732,"src_start":149303},{"artifact":1,"gen_end":193790,"gen_start":193149,"node":265,"role":"declaration","source":0,"src_end":150245,"src_start":149734},{"artifact":1,"gen_end":194096,"gen_start":193790,"node":266,"role":"declaration","source":0,"src_end":150481,"src_start":150247},{"artifact":1,"gen_end":207407,"gen_start":194096,"node":267,"role":"declaration","source":0,"src_end":160558,"src_start":150483},{"artifact":1,"gen_end":208276,"gen_start":207407,"node":268,"role":"declaration","source":0,"src_end":161224,"src_start":160560},{"artifact":1,"gen_end":209258,"gen_start":208276,"node":269,"role":"declaration","source":0,"src_end":162018,"src_start":161226},{"artifact":1,"gen_end":209578,"gen_start":209258,"node":270,"role":"declaration","source":0,"src_end":162260,"src_start":162020},{"artifact":1,"gen_end":219814,"gen_start":209578,"node":271,"role":"declaration","source":0,"src_end":170047,"src_start":162262},{"artifact":1,"gen_end":220386,"gen_start":219814,"node":272,"role":"declaration","source":0,"src_end":170472,"src_start":170049},{"artifact":1,"gen_end":221046,"gen_start":220386,"node":273,"role":"declaration","source":0,"src_end":170992,"src_start":170474},{"artifact":1,"gen_end":221375,"gen_start":221046,"node":274,"role":"declaration","source":0,"src_end":171241,"src_start":170994},{"artifact":1,"gen_end":231784,"gen_start":221375,"node":275,"role":"declaration","source":0,"src_end":179187,"src_start":171243},{"artifact":1,"gen_end":232362,"gen_start":231784,"node":276,"role":"declaration","source":0,"src_end":179618,"src_start":179189},{"artifact":1,"gen_end":233028,"gen_start":232362,"node":277,"role":"declaration","source":0,"src_end":180144,"src_start":179620},{"artifact":1,"gen_end":233363,"gen_start":233028,"node":278,"role":"declaration","source":0,"src_end":180399,"src_start":180146},{"artifact":1,"gen_end":243774,"gen_start":233363,"node":279,"role":"declaration","source":0,"src_end":188347,"src_start":180401},{"artifact":1,"gen_end":244354,"gen_start":243774,"node":280,"role":"declaration","source":0,"src_end":188780,"src_start":188349},{"artifact":1,"gen_end":245022,"gen_start":244354,"node":281,"role":"declaration","source":0,"src_end":189308,"src_start":188782},{"artifact":1,"gen_end":245359,"gen_start":245022,"node":282,"role":"declaration","source":0,"src_end":189565,"src_start":189310},{"artifact":1,"gen_end":316303,"gen_start":245359,"node":283,"role":"declaration","source":0,"src_end":244998,"src_start":189567},{"artifact":1,"gen_end":316696,"gen_start":316303,"node":284,"role":"declaration","source":0,"src_end":245278,"src_start":245000},{"artifact":1,"gen_end":317188,"gen_start":316696,"node":285,"role":"declaration","source":0,"src_end":245654,"src_start":245280},{"artifact":1,"gen_end":317512,"gen_start":317188,"node":286,"role":"declaration","source":0,"src_end":245898,"src_start":245656},{"artifact":1,"gen_end":388460,"gen_start":317512,"node":287,"role":"declaration","source":0,"src_end":301335,"src_start":245900},{"artifact":1,"gen_end":388857,"gen_start":388460,"node":288,"role":"declaration","source":0,"src_end":301619,"src_start":301337},{"artifact":1,"gen_end":389353,"gen_start":388857,"node":289,"role":"declaration","source":0,"src_end":301999,"src_start":301621},{"artifact":1,"gen_end":389676,"gen_start":389353,"node":290,"role":"declaration","source":0,"src_end":302244,"src_start":302001},{"artifact":1,"gen_end":399720,"gen_start":389676,"node":291,"role":"declaration","source":0,"src_end":309867,"src_start":302246},{"artifact":1,"gen_end":400296,"gen_start":399720,"node":292,"role":"declaration","source":0,"src_end":310296,"src_start":309869},{"artifact":1,"gen_end":400644,"gen_start":400296,"node":293,"role":"declaration","source":0,"src_end":310566,"src_start":310298},{"artifact":1,"gen_end":405251,"gen_start":400644,"node":294,"role":"declaration","source":0,"src_end":314109,"src_start":310568},{"artifact":1,"gen_end":405525,"gen_start":405251,"node":295,"role":"declaration","source":0,"src_end":314288,"src_start":314111},{"artifact":1,"gen_end":405873,"gen_start":405525,"node":296,"role":"declaration","source":0,"src_end":314558,"src_start":314290},{"artifact":1,"gen_end":415925,"gen_start":405873,"node":297,"role":"declaration","source":0,"src_end":322189,"src_start":314560},{"artifact":1,"gen_end":416513,"gen_start":415925,"node":298,"role":"declaration","source":0,"src_end":322630,"src_start":322191},{"artifact":1,"gen_end":416873,"gen_start":416513,"node":299,"role":"declaration","source":0,"src_end":322912,"src_start":322632},{"artifact":1,"gen_end":427053,"gen_start":416873,"node":300,"role":"declaration","source":0,"src_end":330649,"src_start":322914},{"artifact":1,"gen_end":427627,"gen_start":427053,"node":301,"role":"declaration","source":0,"src_end":331076,"src_start":330651},{"artifact":1,"gen_end":428023,"gen_start":427627,"node":302,"role":"declaration","source":0,"src_end":331386,"src_start":331078},{"artifact":1,"gen_end":438081,"gen_start":428023,"node":303,"role":"declaration","source":0,"src_end":339021,"src_start":331388},{"artifact":1,"gen_end":438669,"gen_start":438081,"node":304,"role":"declaration","source":0,"src_end":339462,"src_start":339023},{"artifact":1,"gen_end":439066,"gen_start":438669,"node":305,"role":"declaration","source":0,"src_end":339773,"src_start":339464},{"artifact":1,"gen_end":443715,"gen_start":439066,"node":306,"role":"declaration","source":0,"src_end":343352,"src_start":339775},{"artifact":1,"gen_end":443997,"gen_start":443715,"node":307,"role":"declaration","source":0,"src_end":343539,"src_start":343354},{"artifact":1,"gen_end":444357,"gen_start":443997,"node":308,"role":"declaration","source":0,"src_end":343821,"src_start":343541},{"artifact":1,"gen_end":454534,"gen_start":444357,"node":309,"role":"declaration","source":0,"src_end":351555,"src_start":343823},{"artifact":1,"gen_end":455112,"gen_start":454534,"node":310,"role":"declaration","source":0,"src_end":351986,"src_start":351557},{"artifact":1,"gen_end":455504,"gen_start":455112,"node":311,"role":"declaration","source":0,"src_end":352292,"src_start":351988},{"artifact":1,"gen_end":464485,"gen_start":455504,"node":312,"role":"declaration","source":0,"src_end":359050,"src_start":352294},{"artifact":1,"gen_end":465055,"gen_start":464485,"node":313,"role":"declaration","source":0,"src_end":359473,"src_start":359052},{"artifact":1,"gen_end":465394,"gen_start":465055,"node":314,"role":"declaration","source":0,"src_end":359734,"src_start":359475},{"artifact":1,"gen_end":475439,"gen_start":465394,"node":315,"role":"declaration","source":0,"src_end":367358,"src_start":359736},{"artifact":1,"gen_end":476017,"gen_start":475439,"node":316,"role":"declaration","source":0,"src_end":367789,"src_start":367360},{"artifact":1,"gen_end":476407,"gen_start":476017,"node":317,"role":"declaration","source":0,"src_end":368093,"src_start":367791},{"artifact":1,"gen_end":486606,"gen_start":476407,"node":318,"role":"declaration","source":0,"src_end":375849,"src_start":368095},{"artifact":1,"gen_end":487220,"gen_start":486606,"node":319,"role":"declaration","source":0,"src_end":376316,"src_start":375851},{"artifact":1,"gen_end":487656,"gen_start":487220,"node":320,"role":"declaration","source":0,"src_end":376666,"src_start":376318},{"artifact":1,"gen_end":497717,"gen_start":487656,"node":321,"role":"declaration","source":0,"src_end":384302,"src_start":376668},{"artifact":1,"gen_end":498305,"gen_start":497717,"node":322,"role":"declaration","source":0,"src_end":384743,"src_start":384304},{"artifact":1,"gen_end":498667,"gen_start":498305,"node":323,"role":"declaration","source":0,"src_end":385027,"src_start":384745},{"artifact":1,"gen_end":503287,"gen_start":498667,"node":324,"role":"declaration","source":0,"src_end":388583,"src_start":385029},{"artifact":1,"gen_end":503573,"gen_start":503287,"node":325,"role":"declaration","source":0,"src_end":388774,"src_start":388585},{"artifact":1,"gen_end":503939,"gen_start":503573,"node":326,"role":"declaration","source":0,"src_end":389062,"src_start":388776},{"artifact":1,"gen_end":513981,"gen_start":503939,"node":327,"role":"declaration","source":0,"src_end":396683,"src_start":389064},{"artifact":1,"gen_end":514567,"gen_start":513981,"node":328,"role":"declaration","source":0,"src_end":397122,"src_start":396685},{"artifact":1,"gen_end":514930,"gen_start":514567,"node":329,"role":"declaration","source":0,"src_end":397407,"src_start":397124},{"artifact":1,"gen_end":524981,"gen_start":514930,"node":330,"role":"declaration","source":0,"src_end":405037,"src_start":397409},{"artifact":1,"gen_end":525571,"gen_start":524981,"node":331,"role":"declaration","source":0,"src_end":405480,"src_start":405039},{"artifact":1,"gen_end":525940,"gen_start":525571,"node":332,"role":"declaration","source":0,"src_end":405771,"src_start":405482},{"artifact":1,"gen_end":530566,"gen_start":525940,"node":333,"role":"declaration","source":0,"src_end":409333,"src_start":405773},{"artifact":1,"gen_end":530860,"gen_start":530566,"node":334,"role":"declaration","source":0,"src_end":409532,"src_start":409335},{"artifact":1,"gen_end":531238,"gen_start":530860,"node":335,"role":"declaration","source":0,"src_end":409832,"src_start":409534},{"artifact":1,"gen_end":541362,"gen_start":531238,"node":336,"role":"declaration","source":0,"src_end":417529,"src_start":409834},{"artifact":1,"gen_end":541968,"gen_start":541362,"node":337,"role":"declaration","source":0,"src_end":417988,"src_start":417531},{"artifact":1,"gen_end":542348,"gen_start":541968,"node":338,"role":"declaration","source":0,"src_end":418290,"src_start":417990},{"artifact":1,"gen_end":552522,"gen_start":542348,"node":339,"role":"declaration","source":0,"src_end":426021,"src_start":418292},{"artifact":1,"gen_end":553090,"gen_start":552522,"node":340,"role":"declaration","source":0,"src_end":426442,"src_start":426023},{"artifact":1,"gen_end":553477,"gen_start":553090,"node":341,"role":"declaration","source":0,"src_end":426743,"src_start":426444},{"artifact":1,"gen_end":573023,"gen_start":553477,"node":342,"role":"declaration","source":0,"src_end":442012,"src_start":426745},{"artifact":1,"gen_end":573323,"gen_start":573023,"node":343,"role":"declaration","source":0,"src_end":442217,"src_start":442014},{"artifact":1,"gen_end":573701,"gen_start":573323,"node":344,"role":"declaration","source":0,"src_end":442517,"src_start":442219},{"artifact":1,"gen_end":644654,"gen_start":573701,"node":345,"role":"declaration","source":0,"src_end":497959,"src_start":442519},{"artifact":1,"gen_end":645067,"gen_start":644654,"node":346,"role":"declaration","source":0,"src_end":498259,"src_start":497961},{"artifact":1,"gen_end":645463,"gen_start":645067,"node":347,"role":"declaration","source":0,"src_end":498569,"src_start":498261},{"artifact":1,"gen_end":655529,"gen_start":645463,"node":348,"role":"declaration","source":0,"src_end":506214,"src_start":498571},{"artifact":1,"gen_end":656123,"gen_start":655529,"node":349,"role":"declaration","source":0,"src_end":506661,"src_start":506216},{"artifact":1,"gen_end":656485,"gen_start":656123,"node":350,"role":"declaration","source":0,"src_end":506945,"src_start":506663},{"artifact":1,"gen_end":666529,"gen_start":656485,"node":351,"role":"declaration","source":0,"src_end":514568,"src_start":506947},{"artifact":1,"gen_end":667109,"gen_start":666529,"node":352,"role":"declaration","source":0,"src_end":515001,"src_start":514570},{"artifact":1,"gen_end":667461,"gen_start":667109,"node":353,"role":"declaration","source":0,"src_end":515275,"src_start":515003},{"artifact":1,"gen_end":677515,"gen_start":667461,"node":354,"role":"declaration","source":0,"src_end":522908,"src_start":515277},{"artifact":1,"gen_end":678109,"gen_start":677515,"node":355,"role":"declaration","source":0,"src_end":523355,"src_start":522910},{"artifact":1,"gen_end":678488,"gen_start":678109,"node":356,"role":"declaration","source":0,"src_end":523656,"src_start":523357},{"artifact":1,"gen_end":688662,"gen_start":678488,"node":357,"role":"declaration","source":0,"src_end":531387,"src_start":523658},{"artifact":1,"gen_end":689230,"gen_start":688662,"node":358,"role":"declaration","source":0,"src_end":531808,"src_start":531389},{"artifact":1,"gen_end":689617,"gen_start":689230,"node":359,"role":"declaration","source":0,"src_end":532109,"src_start":531810},{"artifact":1,"gen_end":699675,"gen_start":689617,"node":360,"role":"declaration","source":0,"src_end":539746,"src_start":532111},{"artifact":1,"gen_end":700277,"gen_start":699675,"node":361,"role":"declaration","source":0,"src_end":540201,"src_start":539748},{"artifact":1,"gen_end":700664,"gen_start":700277,"node":362,"role":"declaration","source":0,"src_end":540510,"src_start":540203},{"artifact":1,"gen_end":710841,"gen_start":700664,"node":363,"role":"declaration","source":0,"src_end":548244,"src_start":540512},{"artifact":1,"gen_end":711423,"gen_start":710841,"node":364,"role":"declaration","source":0,"src_end":548679,"src_start":548246},{"artifact":1,"gen_end":711812,"gen_start":711423,"node":365,"role":"declaration","source":0,"src_end":548982,"src_start":548681},{"artifact":1,"gen_end":722173,"gen_start":711812,"node":366,"role":"declaration","source":0,"src_end":556882,"src_start":548984},{"artifact":1,"gen_end":722763,"gen_start":722173,"node":367,"role":"declaration","source":0,"src_end":557325,"src_start":556884},{"artifact":1,"gen_end":723171,"gen_start":722763,"node":368,"role":"declaration","source":0,"src_end":557647,"src_start":557327},{"artifact":1,"gen_end":733090,"gen_start":723171,"node":369,"role":"declaration","source":0,"src_end":565167,"src_start":557649},{"artifact":1,"gen_end":733676,"gen_start":733090,"node":370,"role":"declaration","source":0,"src_end":565606,"src_start":565169},{"artifact":1,"gen_end":734078,"gen_start":733676,"node":371,"role":"declaration","source":0,"src_end":565922,"src_start":565608},{"artifact":1,"gen_end":744184,"gen_start":734078,"node":372,"role":"declaration","source":0,"src_end":573603,"src_start":565924},{"artifact":1,"gen_end":744784,"gen_start":744184,"node":373,"role":"declaration","source":0,"src_end":574056,"src_start":573605},{"artifact":1,"gen_end":745205,"gen_start":744784,"node":374,"role":"declaration","source":0,"src_end":574391,"src_start":574058},{"artifact":1,"gen_end":755396,"gen_start":745205,"node":375,"role":"declaration","source":0,"src_end":582139,"src_start":574393},{"artifact":1,"gen_end":755984,"gen_start":755396,"node":376,"role":"declaration","source":0,"src_end":582580,"src_start":582141},{"artifact":1,"gen_end":756394,"gen_start":755984,"node":377,"role":"declaration","source":0,"src_end":582904,"src_start":582582},{"artifact":1,"gen_end":766449,"gen_start":756394,"node":378,"role":"declaration","source":0,"src_end":590538,"src_start":582906},{"artifact":1,"gen_end":767035,"gen_start":766449,"node":379,"role":"declaration","source":0,"src_end":590977,"src_start":590540},{"artifact":1,"gen_end":767431,"gen_start":767035,"node":380,"role":"declaration","source":0,"src_end":591287,"src_start":590979},{"artifact":1,"gen_end":777626,"gen_start":767431,"node":381,"role":"declaration","source":0,"src_end":599039,"src_start":591289},{"artifact":1,"gen_end":778220,"gen_start":777626,"node":382,"role":"declaration","source":0,"src_end":599486,"src_start":599041},{"artifact":1,"gen_end":778628,"gen_start":778220,"node":383,"role":"declaration","source":0,"src_end":599808,"src_start":599488},{"artifact":1,"gen_end":788671,"gen_start":778628,"node":384,"role":"declaration","source":0,"src_end":607430,"src_start":599810},{"artifact":1,"gen_end":789251,"gen_start":788671,"node":385,"role":"declaration","source":0,"src_end":607863,"src_start":607432},{"artifact":1,"gen_end":789605,"gen_start":789251,"node":386,"role":"declaration","source":0,"src_end":608139,"src_start":607865},{"artifact":1,"gen_end":799648,"gen_start":789605,"node":387,"role":"declaration","source":0,"src_end":615761,"src_start":608141},{"artifact":1,"gen_end":800228,"gen_start":799648,"node":388,"role":"declaration","source":0,"src_end":616194,"src_start":615763},{"artifact":1,"gen_end":800582,"gen_start":800228,"node":389,"role":"declaration","source":0,"src_end":616470,"src_start":616196},{"artifact":1,"gen_end":810637,"gen_start":800582,"node":390,"role":"declaration","source":0,"src_end":624104,"src_start":616472},{"artifact":1,"gen_end":811227,"gen_start":810637,"node":391,"role":"declaration","source":0,"src_end":624547,"src_start":624106},{"artifact":1,"gen_end":811600,"gen_start":811227,"node":392,"role":"declaration","source":0,"src_end":624842,"src_start":624549},{"artifact":1,"gen_end":821654,"gen_start":811600,"node":393,"role":"declaration","source":0,"src_end":632473,"src_start":624844},{"artifact":1,"gen_end":822234,"gen_start":821654,"node":394,"role":"declaration","source":0,"src_end":632906,"src_start":632475},{"artifact":1,"gen_end":822623,"gen_start":822234,"node":395,"role":"declaration","source":0,"src_end":633209,"src_start":632908},{"artifact":1,"gen_end":832818,"gen_start":822623,"node":396,"role":"declaration","source":0,"src_end":640959,"src_start":633211},{"artifact":1,"gen_end":833408,"gen_start":832818,"node":397,"role":"declaration","source":0,"src_end":641402,"src_start":640961},{"artifact":1,"gen_end":833812,"gen_start":833408,"node":398,"role":"declaration","source":0,"src_end":641720,"src_start":641404},{"artifact":1,"gen_end":843157,"gen_start":833812,"node":399,"role":"declaration","source":0,"src_end":648764,"src_start":641722},{"artifact":1,"gen_end":843719,"gen_start":843157,"node":400,"role":"declaration","source":0,"src_end":649179,"src_start":648766},{"artifact":1,"gen_end":844365,"gen_start":843719,"node":401,"role":"declaration","source":0,"src_end":649685,"src_start":649181},{"artifact":1,"gen_end":844683,"gen_start":844365,"node":402,"role":"declaration","source":0,"src_end":649923,"src_start":649687},{"artifact":1,"gen_end":855272,"gen_start":844683,"node":403,"role":"declaration","source":0,"src_end":657956,"src_start":649925},{"artifact":1,"gen_end":855677,"gen_start":855272,"node":404,"role":"declaration","source":0,"src_end":658248,"src_start":657958},{"artifact":1,"gen_end":856166,"gen_start":855677,"node":405,"role":"declaration","source":0,"src_end":658625,"src_start":658250},{"artifact":1,"gen_end":856472,"gen_start":856166,"node":406,"role":"declaration","source":0,"src_end":658861,"src_start":658627},{"artifact":1,"gen_end":870686,"gen_start":856472,"node":407,"role":"declaration","source":0,"src_end":669575,"src_start":658863},{"artifact":1,"gen_end":871130,"gen_start":870686,"node":408,"role":"declaration","source":0,"src_end":669900,"src_start":669577},{"artifact":1,"gen_end":871678,"gen_start":871130,"node":409,"role":"declaration","source":0,"src_end":670324,"src_start":669902},{"artifact":1,"gen_end":872019,"gen_start":871678,"node":410,"role":"declaration","source":0,"src_end":670591,"src_start":670326},{"artifact":1,"gen_end":872364,"gen_start":872019,"node":411,"role":"declaration","source":0,"src_end":670858,"src_start":670593},{"artifact":1,"gen_end":872709,"gen_start":872364,"node":412,"role":"declaration","source":0,"src_end":671125,"src_start":670860},{"artifact":1,"gen_end":873054,"gen_start":872709,"node":413,"role":"declaration","source":0,"src_end":671392,"src_start":671127},{"artifact":1,"gen_end":873408,"gen_start":873054,"node":414,"role":"declaration","source":0,"src_end":671670,"src_start":671394},{"artifact":1,"gen_end":873697,"gen_start":873408,"node":415,"role":"declaration","source":0,"src_end":671895,"src_start":671672},{"artifact":1,"gen_end":883735,"gen_start":873697,"node":416,"role":"declaration","source":0,"src_end":679512,"src_start":671897},{"artifact":1,"gen_end":884297,"gen_start":883735,"node":417,"role":"declaration","source":0,"src_end":679927,"src_start":679514},{"artifact":1,"gen_end":884947,"gen_start":884297,"node":418,"role":"declaration","source":0,"src_end":680437,"src_start":679929},{"artifact":1,"gen_end":885266,"gen_start":884947,"node":419,"role":"declaration","source":0,"src_end":680676,"src_start":680439},{"artifact":1,"gen_end":885281,"gen_start":885266,"node":210,"role":"declaration","source":0,"src_end":680712,"src_start":0}],"module":"GnafFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-latex-module"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-declaration"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"},{"id":348,"kind":"semantic-declaration"},{"id":349,"kind":"semantic-declaration"},{"id":350,"kind":"semantic-declaration"},{"id":351,"kind":"semantic-declaration"},{"id":352,"kind":"semantic-declaration"},{"id":353,"kind":"semantic-declaration"},{"id":354,"kind":"semantic-declaration"},{"id":355,"kind":"semantic-declaration"},{"id":356,"kind":"semantic-declaration"},{"id":357,"kind":"semantic-declaration"},{"id":358,"kind":"semantic-declaration"},{"id":359,"kind":"semantic-declaration"},{"id":360,"kind":"semantic-declaration"},{"id":361,"kind":"semantic-declaration"},{"id":362,"kind":"semantic-declaration"},{"id":363,"kind":"semantic-declaration"},{"id":364,"kind":"semantic-declaration"},{"id":365,"kind":"semantic-declaration"},{"id":366,"kind":"semantic-declaration"},{"id":367,"kind":"semantic-declaration"},{"id":368,"kind":"semantic-declaration"},{"id":369,"kind":"semantic-declaration"},{"id":370,"kind":"semantic-declaration"},{"id":371,"kind":"semantic-declaration"},{"id":372,"kind":"semantic-declaration"},{"id":373,"kind":"semantic-declaration"},{"id":374,"kind":"semantic-declaration"},{"id":375,"kind":"semantic-declaration"},{"id":376,"kind":"semantic-declaration"},{"id":377,"kind":"semantic-declaration"},{"id":378,"kind":"semantic-declaration"},{"id":379,"kind":"semantic-declaration"},{"id":380,"kind":"semantic-declaration"},{"id":381,"kind":"semantic-declaration"},{"id":382,"kind":"semantic-declaration"},{"id":383,"kind":"semantic-declaration"},{"id":384,"kind":"semantic-declaration"},{"id":385,"kind":"semantic-declaration"},{"id":386,"kind":"semantic-declaration"},{"id":387,"kind":"semantic-declaration"},{"id":388,"kind":"semantic-declaration"},{"id":389,"kind":"semantic-declaration"},{"id":390,"kind":"semantic-declaration"},{"id":391,"kind":"semantic-declaration"},{"id":392,"kind":"semantic-declaration"},{"id":393,"kind":"semantic-declaration"},{"id":394,"kind":"semantic-declaration"},{"id":395,"kind":"semantic-declaration"},{"id":396,"kind":"semantic-declaration"},{"id":397,"kind":"semantic-declaration"},{"id":398,"kind":"semantic-declaration"},{"id":399,"kind":"semantic-declaration"},{"id":400,"kind":"semantic-declaration"},{"id":401,"kind":"semantic-declaration"},{"id":402,"kind":"semantic-declaration"},{"id":403,"kind":"semantic-declaration"},{"id":404,"kind":"semantic-declaration"},{"id":405,"kind":"semantic-declaration"},{"id":406,"kind":"semantic-declaration"},{"id":407,"kind":"semantic-declaration"},{"id":408,"kind":"semantic-declaration"},{"id":409,"kind":"semantic-declaration"},{"id":410,"kind":"semantic-declaration"},{"id":411,"kind":"semantic-declaration"},{"id":412,"kind":"semantic-declaration"},{"id":413,"kind":"semantic-declaration"},{"id":414,"kind":"semantic-declaration"},{"id":415,"kind":"semantic-declaration"},{"id":416,"kind":"semantic-declaration"},{"id":417,"kind":"semantic-declaration"},{"id":418,"kind":"semantic-declaration"},{"id":419,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/GnafFixtures.lex.tex","sha256":"e7f06e087d0ec40b8dd61f2fe1c51258ec55d93f5e5e16938c27598661e8d913"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/GradeOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/GradeOracle.map.json index 1ab1ed40e..adbd4e920 100644 --- a/compiler/expected/build/maps/LexLeanTarget/GradeOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/GradeOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GradeOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GradeOracle.tex"}],"mappings":[{"artifact":0,"gen_end":404,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":0,"gen_end":580,"gen_start":404,"node":1,"role":"declaration","source":0,"src_end":318,"src_start":151},{"artifact":0,"gen_end":772,"gen_start":580,"node":2,"role":"declaration","source":0,"src_end":520,"src_start":320},{"artifact":0,"gen_end":3946,"gen_start":772,"node":3,"role":"declaration","source":0,"src_end":849,"src_start":522},{"artifact":0,"gen_end":4124,"gen_start":3946,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":851},{"artifact":0,"gen_end":4480,"gen_start":4124,"node":5,"role":"declaration","source":0,"src_end":1498,"src_start":1087},{"artifact":0,"gen_end":4836,"gen_start":4480,"node":6,"role":"declaration","source":0,"src_end":1893,"src_start":1500},{"artifact":0,"gen_end":5191,"gen_start":4836,"node":7,"role":"declaration","source":0,"src_end":2242,"src_start":1895},{"artifact":0,"gen_end":8521,"gen_start":5191,"node":8,"role":"declaration","source":0,"src_end":2737,"src_start":2244},{"artifact":0,"gen_end":12050,"gen_start":8521,"node":9,"role":"declaration","source":0,"src_end":3361,"src_start":2739},{"artifact":0,"gen_end":15351,"gen_start":12050,"node":10,"role":"declaration","source":0,"src_end":3856,"src_start":3363},{"artifact":0,"gen_end":44774,"gen_start":15351,"node":11,"role":"declaration","source":0,"src_end":4994,"src_start":3858},{"artifact":0,"gen_end":44805,"gen_start":44774,"node":0,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":12,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":1,"gen_end":496,"gen_start":134,"node":13,"role":"declaration","source":0,"src_end":318,"src_start":151},{"artifact":1,"gen_end":937,"gen_start":496,"node":14,"role":"declaration","source":0,"src_end":520,"src_start":320},{"artifact":1,"gen_end":1269,"gen_start":937,"node":15,"role":"declaration","source":0,"src_end":849,"src_start":522},{"artifact":1,"gen_end":2003,"gen_start":1269,"node":16,"role":"declaration","source":0,"src_end":1085,"src_start":851},{"artifact":1,"gen_end":2492,"gen_start":2003,"node":17,"role":"declaration","source":0,"src_end":1498,"src_start":1087},{"artifact":1,"gen_end":2966,"gen_start":2492,"node":18,"role":"declaration","source":0,"src_end":1893,"src_start":1500},{"artifact":1,"gen_end":3537,"gen_start":2966,"node":19,"role":"declaration","source":0,"src_end":2242,"src_start":1895},{"artifact":1,"gen_end":3999,"gen_start":3537,"node":20,"role":"declaration","source":0,"src_end":2737,"src_start":2244},{"artifact":1,"gen_end":4451,"gen_start":3999,"node":21,"role":"declaration","source":0,"src_end":3361,"src_start":2739},{"artifact":1,"gen_end":4874,"gen_start":4451,"node":22,"role":"declaration","source":0,"src_end":3856,"src_start":3363},{"artifact":1,"gen_end":26676,"gen_start":4874,"node":23,"role":"declaration","source":0,"src_end":4994,"src_start":3858},{"artifact":1,"gen_end":26691,"gen_start":26676,"node":12,"role":"declaration","source":0,"src_end":5030,"src_start":0}],"module":"GradeOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-latex-module"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/GradeOracle.lex.tex","sha256":"1e19782f0fd76c6d49b5f7f5f29569f8f52b5d91397f0ec9921286cdd03b0fd0"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/GradeOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/GradeOracle.tex"}],"mappings":[{"artifact":0,"gen_end":404,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":0,"gen_end":580,"gen_start":404,"node":1,"role":"declaration","source":0,"src_end":318,"src_start":151},{"artifact":0,"gen_end":772,"gen_start":580,"node":2,"role":"declaration","source":0,"src_end":520,"src_start":320},{"artifact":0,"gen_end":3946,"gen_start":772,"node":3,"role":"declaration","source":0,"src_end":849,"src_start":522},{"artifact":0,"gen_end":4124,"gen_start":3946,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":851},{"artifact":0,"gen_end":4480,"gen_start":4124,"node":5,"role":"declaration","source":0,"src_end":1498,"src_start":1087},{"artifact":0,"gen_end":4836,"gen_start":4480,"node":6,"role":"declaration","source":0,"src_end":1893,"src_start":1500},{"artifact":0,"gen_end":5191,"gen_start":4836,"node":7,"role":"declaration","source":0,"src_end":2242,"src_start":1895},{"artifact":0,"gen_end":8521,"gen_start":5191,"node":8,"role":"declaration","source":0,"src_end":2737,"src_start":2244},{"artifact":0,"gen_end":12050,"gen_start":8521,"node":9,"role":"declaration","source":0,"src_end":3361,"src_start":2739},{"artifact":0,"gen_end":15351,"gen_start":12050,"node":10,"role":"declaration","source":0,"src_end":3856,"src_start":3363},{"artifact":0,"gen_end":44774,"gen_start":15351,"node":11,"role":"declaration","source":0,"src_end":4994,"src_start":3858},{"artifact":0,"gen_end":44805,"gen_start":44774,"node":0,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":12,"role":"declaration","source":0,"src_end":5030,"src_start":0},{"artifact":1,"gen_end":496,"gen_start":134,"node":13,"role":"declaration","source":0,"src_end":318,"src_start":151},{"artifact":1,"gen_end":937,"gen_start":496,"node":14,"role":"declaration","source":0,"src_end":520,"src_start":320},{"artifact":1,"gen_end":1269,"gen_start":937,"node":15,"role":"declaration","source":0,"src_end":849,"src_start":522},{"artifact":1,"gen_end":2003,"gen_start":1269,"node":16,"role":"declaration","source":0,"src_end":1085,"src_start":851},{"artifact":1,"gen_end":2492,"gen_start":2003,"node":17,"role":"declaration","source":0,"src_end":1498,"src_start":1087},{"artifact":1,"gen_end":2966,"gen_start":2492,"node":18,"role":"declaration","source":0,"src_end":1893,"src_start":1500},{"artifact":1,"gen_end":3537,"gen_start":2966,"node":19,"role":"declaration","source":0,"src_end":2242,"src_start":1895},{"artifact":1,"gen_end":3999,"gen_start":3537,"node":20,"role":"declaration","source":0,"src_end":2737,"src_start":2244},{"artifact":1,"gen_end":4451,"gen_start":3999,"node":21,"role":"declaration","source":0,"src_end":3361,"src_start":2739},{"artifact":1,"gen_end":4874,"gen_start":4451,"node":22,"role":"declaration","source":0,"src_end":3856,"src_start":3363},{"artifact":1,"gen_end":26676,"gen_start":4874,"node":23,"role":"declaration","source":0,"src_end":4994,"src_start":3858},{"artifact":1,"gen_end":26691,"gen_start":26676,"node":12,"role":"declaration","source":0,"src_end":5030,"src_start":0}],"module":"GradeOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-latex-module"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/GradeOracle.lex.tex","sha256":"1e19782f0fd76c6d49b5f7f5f29569f8f52b5d91397f0ec9921286cdd03b0fd0"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/Main.map.json b/compiler/expected/build/maps/LexLeanTarget/Main.map.json index 72b4aeebc..6a9677cf6 100644 --- a/compiler/expected/build/maps/LexLeanTarget/Main.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Main.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Main.tex"}],"mappings":[{"artifact":0,"gen_end":869,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":0,"gen_end":1104,"gen_start":869,"node":1,"role":"declaration","source":0,"src_end":775,"src_start":573},{"artifact":0,"gen_end":1128,"gen_start":1104,"node":0,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":2,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":1,"gen_end":517,"gen_start":134,"node":3,"role":"declaration","source":0,"src_end":775,"src_start":573},{"artifact":1,"gen_end":532,"gen_start":517,"node":2,"role":"declaration","source":0,"src_end":811,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-latex-module"},{"id":3,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"a26d3c220ec1352dd96565ac2308c1684a945a98e1210b3dfaab30cd76dc1875"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/Main.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/Main.tex"}],"mappings":[{"artifact":0,"gen_end":869,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":0,"gen_end":1104,"gen_start":869,"node":1,"role":"declaration","source":0,"src_end":775,"src_start":573},{"artifact":0,"gen_end":1128,"gen_start":1104,"node":0,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":2,"role":"declaration","source":0,"src_end":811,"src_start":0},{"artifact":1,"gen_end":517,"gen_start":134,"node":3,"role":"declaration","source":0,"src_end":775,"src_start":573},{"artifact":1,"gen_end":532,"gen_start":517,"node":2,"role":"declaration","source":0,"src_end":811,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-latex-module"},{"id":3,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"a26d3c220ec1352dd96565ac2308c1684a945a98e1210b3dfaab30cd76dc1875"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/PlannerOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/PlannerOracle.map.json index 38eb9fec5..072fec777 100644 --- a/compiler/expected/build/maps/LexLeanTarget/PlannerOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/PlannerOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/PlannerOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/PlannerOracle.tex"}],"mappings":[{"artifact":0,"gen_end":362,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":0,"gen_end":493,"gen_start":362,"node":1,"role":"declaration","source":0,"src_end":264,"src_start":122},{"artifact":0,"gen_end":597,"gen_start":493,"node":2,"role":"declaration","source":0,"src_end":390,"src_start":266},{"artifact":0,"gen_end":3664,"gen_start":597,"node":3,"role":"declaration","source":0,"src_end":580,"src_start":392},{"artifact":0,"gen_end":3847,"gen_start":3664,"node":4,"role":"declaration","source":0,"src_end":727,"src_start":582},{"artifact":0,"gen_end":6929,"gen_start":3847,"node":5,"role":"declaration","source":0,"src_end":988,"src_start":729},{"artifact":0,"gen_end":7795,"gen_start":6929,"node":6,"role":"declaration","source":0,"src_end":1228,"src_start":990},{"artifact":0,"gen_end":10878,"gen_start":7795,"node":7,"role":"declaration","source":0,"src_end":1489,"src_start":1230},{"artifact":0,"gen_end":11754,"gen_start":10878,"node":8,"role":"declaration","source":0,"src_end":1730,"src_start":1491},{"artifact":0,"gen_end":14926,"gen_start":11754,"node":9,"role":"declaration","source":0,"src_end":2067,"src_start":1732},{"artifact":0,"gen_end":16045,"gen_start":14926,"node":10,"role":"declaration","source":0,"src_end":2456,"src_start":2069},{"artifact":0,"gen_end":16172,"gen_start":16045,"node":11,"role":"declaration","source":0,"src_end":2604,"src_start":2458},{"artifact":0,"gen_end":16312,"gen_start":16172,"node":12,"role":"declaration","source":0,"src_end":2779,"src_start":2606},{"artifact":0,"gen_end":19407,"gen_start":16312,"node":13,"role":"declaration","source":0,"src_end":3023,"src_start":2781},{"artifact":0,"gen_end":19600,"gen_start":19407,"node":14,"role":"declaration","source":0,"src_end":3231,"src_start":3025},{"artifact":0,"gen_end":22603,"gen_start":19600,"node":15,"role":"declaration","source":0,"src_end":3424,"src_start":3233},{"artifact":0,"gen_end":53421,"gen_start":22603,"node":16,"role":"declaration","source":0,"src_end":3997,"src_start":3426},{"artifact":0,"gen_end":53506,"gen_start":53421,"node":17,"role":"declaration","source":0,"src_end":4090,"src_start":3999},{"artifact":0,"gen_end":53594,"gen_start":53506,"node":18,"role":"declaration","source":0,"src_end":4219,"src_start":4092},{"artifact":0,"gen_end":56664,"gen_start":53594,"node":19,"role":"declaration","source":0,"src_end":4445,"src_start":4221},{"artifact":0,"gen_end":56849,"gen_start":56664,"node":20,"role":"declaration","source":0,"src_end":4637,"src_start":4447},{"artifact":0,"gen_end":56933,"gen_start":56849,"node":21,"role":"declaration","source":0,"src_end":4729,"src_start":4639},{"artifact":0,"gen_end":57020,"gen_start":56933,"node":22,"role":"declaration","source":0,"src_end":4857,"src_start":4731},{"artifact":0,"gen_end":60085,"gen_start":57020,"node":23,"role":"declaration","source":0,"src_end":5078,"src_start":4859},{"artifact":0,"gen_end":60269,"gen_start":60085,"node":24,"role":"declaration","source":0,"src_end":5269,"src_start":5080},{"artifact":0,"gen_end":63381,"gen_start":60269,"node":25,"role":"declaration","source":0,"src_end":5569,"src_start":5271},{"artifact":0,"gen_end":63519,"gen_start":63381,"node":26,"role":"declaration","source":0,"src_end":5723,"src_start":5571},{"artifact":0,"gen_end":66534,"gen_start":63519,"node":27,"role":"declaration","source":0,"src_end":5927,"src_start":5725},{"artifact":0,"gen_end":69645,"gen_start":66534,"node":28,"role":"declaration","source":0,"src_end":6207,"src_start":5929},{"artifact":0,"gen_end":72773,"gen_start":69645,"node":29,"role":"declaration","source":0,"src_end":6521,"src_start":6209},{"artifact":0,"gen_end":75865,"gen_start":72773,"node":30,"role":"declaration","source":0,"src_end":6801,"src_start":6523},{"artifact":0,"gen_end":107360,"gen_start":75865,"node":31,"role":"declaration","source":0,"src_end":7410,"src_start":6803},{"artifact":0,"gen_end":139950,"gen_start":107360,"node":32,"role":"declaration","source":0,"src_end":8079,"src_start":7412},{"artifact":0,"gen_end":171694,"gen_start":139950,"node":33,"role":"declaration","source":0,"src_end":8649,"src_start":8081},{"artifact":0,"gen_end":171727,"gen_start":171694,"node":0,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":34,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":1,"gen_end":450,"gen_start":134,"node":35,"role":"declaration","source":0,"src_end":264,"src_start":122},{"artifact":1,"gen_end":740,"gen_start":450,"node":36,"role":"declaration","source":0,"src_end":390,"src_start":266},{"artifact":1,"gen_end":1018,"gen_start":740,"node":37,"role":"declaration","source":0,"src_end":580,"src_start":392},{"artifact":1,"gen_end":1647,"gen_start":1018,"node":38,"role":"declaration","source":0,"src_end":727,"src_start":582},{"artifact":1,"gen_end":1989,"gen_start":1647,"node":39,"role":"declaration","source":0,"src_end":988,"src_start":729},{"artifact":1,"gen_end":3308,"gen_start":1989,"node":40,"role":"declaration","source":0,"src_end":1228,"src_start":990},{"artifact":1,"gen_end":3651,"gen_start":3308,"node":41,"role":"declaration","source":0,"src_end":1489,"src_start":1230},{"artifact":1,"gen_end":4981,"gen_start":3651,"node":42,"role":"declaration","source":0,"src_end":1730,"src_start":1491},{"artifact":1,"gen_end":5415,"gen_start":4981,"node":43,"role":"declaration","source":0,"src_end":2067,"src_start":1732},{"artifact":1,"gen_end":7272,"gen_start":5415,"node":44,"role":"declaration","source":0,"src_end":2456,"src_start":2069},{"artifact":1,"gen_end":7585,"gen_start":7272,"node":45,"role":"declaration","source":0,"src_end":2604,"src_start":2458},{"artifact":1,"gen_end":7974,"gen_start":7585,"node":46,"role":"declaration","source":0,"src_end":2779,"src_start":2606},{"artifact":1,"gen_end":8279,"gen_start":7974,"node":47,"role":"declaration","source":0,"src_end":3023,"src_start":2781},{"artifact":1,"gen_end":8992,"gen_start":8279,"node":48,"role":"declaration","source":0,"src_end":3231,"src_start":3025},{"artifact":1,"gen_end":9254,"gen_start":8992,"node":49,"role":"declaration","source":0,"src_end":3424,"src_start":3233},{"artifact":1,"gen_end":27419,"gen_start":9254,"node":50,"role":"declaration","source":0,"src_end":3997,"src_start":3426},{"artifact":1,"gen_end":27674,"gen_start":27419,"node":51,"role":"declaration","source":0,"src_end":4090,"src_start":3999},{"artifact":1,"gen_end":28008,"gen_start":27674,"node":52,"role":"declaration","source":0,"src_end":4219,"src_start":4092},{"artifact":1,"gen_end":28292,"gen_start":28008,"node":53,"role":"declaration","source":0,"src_end":4445,"src_start":4221},{"artifact":1,"gen_end":28953,"gen_start":28292,"node":54,"role":"declaration","source":0,"src_end":4637,"src_start":4447},{"artifact":1,"gen_end":29207,"gen_start":28953,"node":55,"role":"declaration","source":0,"src_end":4729,"src_start":4639},{"artifact":1,"gen_end":29540,"gen_start":29207,"node":56,"role":"declaration","source":0,"src_end":4857,"src_start":4731},{"artifact":1,"gen_end":29821,"gen_start":29540,"node":57,"role":"declaration","source":0,"src_end":5078,"src_start":4859},{"artifact":1,"gen_end":30480,"gen_start":29821,"node":58,"role":"declaration","source":0,"src_end":5269,"src_start":5080},{"artifact":1,"gen_end":30826,"gen_start":30480,"node":59,"role":"declaration","source":0,"src_end":5569,"src_start":5271},{"artifact":1,"gen_end":31150,"gen_start":30826,"node":60,"role":"declaration","source":0,"src_end":5723,"src_start":5571},{"artifact":1,"gen_end":31418,"gen_start":31150,"node":61,"role":"declaration","source":0,"src_end":5927,"src_start":5725},{"artifact":1,"gen_end":31775,"gen_start":31418,"node":62,"role":"declaration","source":0,"src_end":6207,"src_start":5929},{"artifact":1,"gen_end":32131,"gen_start":31775,"node":63,"role":"declaration","source":0,"src_end":6521,"src_start":6209},{"artifact":1,"gen_end":32464,"gen_start":32131,"node":64,"role":"declaration","source":0,"src_end":6801,"src_start":6523},{"artifact":1,"gen_end":51452,"gen_start":32464,"node":65,"role":"declaration","source":0,"src_end":7410,"src_start":6803},{"artifact":1,"gen_end":71336,"gen_start":51452,"node":66,"role":"declaration","source":0,"src_end":8079,"src_start":7412},{"artifact":1,"gen_end":90352,"gen_start":71336,"node":67,"role":"declaration","source":0,"src_end":8649,"src_start":8081},{"artifact":1,"gen_end":90367,"gen_start":90352,"node":34,"role":"declaration","source":0,"src_end":8685,"src_start":0}],"module":"PlannerOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-latex-module"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/PlannerOracle.lex.tex","sha256":"8579b13fcc26a5bdd3323388f400d1b0b805359f96fe4beea29b26bbaa79f50b"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/PlannerOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/PlannerOracle.tex"}],"mappings":[{"artifact":0,"gen_end":362,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":0,"gen_end":493,"gen_start":362,"node":1,"role":"declaration","source":0,"src_end":264,"src_start":122},{"artifact":0,"gen_end":597,"gen_start":493,"node":2,"role":"declaration","source":0,"src_end":390,"src_start":266},{"artifact":0,"gen_end":3664,"gen_start":597,"node":3,"role":"declaration","source":0,"src_end":580,"src_start":392},{"artifact":0,"gen_end":3847,"gen_start":3664,"node":4,"role":"declaration","source":0,"src_end":727,"src_start":582},{"artifact":0,"gen_end":6929,"gen_start":3847,"node":5,"role":"declaration","source":0,"src_end":988,"src_start":729},{"artifact":0,"gen_end":7795,"gen_start":6929,"node":6,"role":"declaration","source":0,"src_end":1228,"src_start":990},{"artifact":0,"gen_end":10878,"gen_start":7795,"node":7,"role":"declaration","source":0,"src_end":1489,"src_start":1230},{"artifact":0,"gen_end":11754,"gen_start":10878,"node":8,"role":"declaration","source":0,"src_end":1730,"src_start":1491},{"artifact":0,"gen_end":14926,"gen_start":11754,"node":9,"role":"declaration","source":0,"src_end":2067,"src_start":1732},{"artifact":0,"gen_end":16045,"gen_start":14926,"node":10,"role":"declaration","source":0,"src_end":2456,"src_start":2069},{"artifact":0,"gen_end":16172,"gen_start":16045,"node":11,"role":"declaration","source":0,"src_end":2604,"src_start":2458},{"artifact":0,"gen_end":16312,"gen_start":16172,"node":12,"role":"declaration","source":0,"src_end":2779,"src_start":2606},{"artifact":0,"gen_end":19407,"gen_start":16312,"node":13,"role":"declaration","source":0,"src_end":3023,"src_start":2781},{"artifact":0,"gen_end":19600,"gen_start":19407,"node":14,"role":"declaration","source":0,"src_end":3231,"src_start":3025},{"artifact":0,"gen_end":22603,"gen_start":19600,"node":15,"role":"declaration","source":0,"src_end":3424,"src_start":3233},{"artifact":0,"gen_end":53421,"gen_start":22603,"node":16,"role":"declaration","source":0,"src_end":3997,"src_start":3426},{"artifact":0,"gen_end":53506,"gen_start":53421,"node":17,"role":"declaration","source":0,"src_end":4090,"src_start":3999},{"artifact":0,"gen_end":53594,"gen_start":53506,"node":18,"role":"declaration","source":0,"src_end":4219,"src_start":4092},{"artifact":0,"gen_end":56664,"gen_start":53594,"node":19,"role":"declaration","source":0,"src_end":4445,"src_start":4221},{"artifact":0,"gen_end":56849,"gen_start":56664,"node":20,"role":"declaration","source":0,"src_end":4637,"src_start":4447},{"artifact":0,"gen_end":56933,"gen_start":56849,"node":21,"role":"declaration","source":0,"src_end":4729,"src_start":4639},{"artifact":0,"gen_end":57020,"gen_start":56933,"node":22,"role":"declaration","source":0,"src_end":4857,"src_start":4731},{"artifact":0,"gen_end":60085,"gen_start":57020,"node":23,"role":"declaration","source":0,"src_end":5078,"src_start":4859},{"artifact":0,"gen_end":60269,"gen_start":60085,"node":24,"role":"declaration","source":0,"src_end":5269,"src_start":5080},{"artifact":0,"gen_end":63381,"gen_start":60269,"node":25,"role":"declaration","source":0,"src_end":5569,"src_start":5271},{"artifact":0,"gen_end":63519,"gen_start":63381,"node":26,"role":"declaration","source":0,"src_end":5723,"src_start":5571},{"artifact":0,"gen_end":66534,"gen_start":63519,"node":27,"role":"declaration","source":0,"src_end":5927,"src_start":5725},{"artifact":0,"gen_end":69645,"gen_start":66534,"node":28,"role":"declaration","source":0,"src_end":6207,"src_start":5929},{"artifact":0,"gen_end":72773,"gen_start":69645,"node":29,"role":"declaration","source":0,"src_end":6521,"src_start":6209},{"artifact":0,"gen_end":75865,"gen_start":72773,"node":30,"role":"declaration","source":0,"src_end":6801,"src_start":6523},{"artifact":0,"gen_end":107360,"gen_start":75865,"node":31,"role":"declaration","source":0,"src_end":7410,"src_start":6803},{"artifact":0,"gen_end":139950,"gen_start":107360,"node":32,"role":"declaration","source":0,"src_end":8079,"src_start":7412},{"artifact":0,"gen_end":171694,"gen_start":139950,"node":33,"role":"declaration","source":0,"src_end":8649,"src_start":8081},{"artifact":0,"gen_end":171727,"gen_start":171694,"node":0,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":34,"role":"declaration","source":0,"src_end":8685,"src_start":0},{"artifact":1,"gen_end":450,"gen_start":134,"node":35,"role":"declaration","source":0,"src_end":264,"src_start":122},{"artifact":1,"gen_end":740,"gen_start":450,"node":36,"role":"declaration","source":0,"src_end":390,"src_start":266},{"artifact":1,"gen_end":1018,"gen_start":740,"node":37,"role":"declaration","source":0,"src_end":580,"src_start":392},{"artifact":1,"gen_end":1647,"gen_start":1018,"node":38,"role":"declaration","source":0,"src_end":727,"src_start":582},{"artifact":1,"gen_end":1989,"gen_start":1647,"node":39,"role":"declaration","source":0,"src_end":988,"src_start":729},{"artifact":1,"gen_end":3308,"gen_start":1989,"node":40,"role":"declaration","source":0,"src_end":1228,"src_start":990},{"artifact":1,"gen_end":3651,"gen_start":3308,"node":41,"role":"declaration","source":0,"src_end":1489,"src_start":1230},{"artifact":1,"gen_end":4981,"gen_start":3651,"node":42,"role":"declaration","source":0,"src_end":1730,"src_start":1491},{"artifact":1,"gen_end":5415,"gen_start":4981,"node":43,"role":"declaration","source":0,"src_end":2067,"src_start":1732},{"artifact":1,"gen_end":7272,"gen_start":5415,"node":44,"role":"declaration","source":0,"src_end":2456,"src_start":2069},{"artifact":1,"gen_end":7585,"gen_start":7272,"node":45,"role":"declaration","source":0,"src_end":2604,"src_start":2458},{"artifact":1,"gen_end":7974,"gen_start":7585,"node":46,"role":"declaration","source":0,"src_end":2779,"src_start":2606},{"artifact":1,"gen_end":8279,"gen_start":7974,"node":47,"role":"declaration","source":0,"src_end":3023,"src_start":2781},{"artifact":1,"gen_end":8992,"gen_start":8279,"node":48,"role":"declaration","source":0,"src_end":3231,"src_start":3025},{"artifact":1,"gen_end":9254,"gen_start":8992,"node":49,"role":"declaration","source":0,"src_end":3424,"src_start":3233},{"artifact":1,"gen_end":27419,"gen_start":9254,"node":50,"role":"declaration","source":0,"src_end":3997,"src_start":3426},{"artifact":1,"gen_end":27674,"gen_start":27419,"node":51,"role":"declaration","source":0,"src_end":4090,"src_start":3999},{"artifact":1,"gen_end":28008,"gen_start":27674,"node":52,"role":"declaration","source":0,"src_end":4219,"src_start":4092},{"artifact":1,"gen_end":28292,"gen_start":28008,"node":53,"role":"declaration","source":0,"src_end":4445,"src_start":4221},{"artifact":1,"gen_end":28953,"gen_start":28292,"node":54,"role":"declaration","source":0,"src_end":4637,"src_start":4447},{"artifact":1,"gen_end":29207,"gen_start":28953,"node":55,"role":"declaration","source":0,"src_end":4729,"src_start":4639},{"artifact":1,"gen_end":29540,"gen_start":29207,"node":56,"role":"declaration","source":0,"src_end":4857,"src_start":4731},{"artifact":1,"gen_end":29821,"gen_start":29540,"node":57,"role":"declaration","source":0,"src_end":5078,"src_start":4859},{"artifact":1,"gen_end":30480,"gen_start":29821,"node":58,"role":"declaration","source":0,"src_end":5269,"src_start":5080},{"artifact":1,"gen_end":30826,"gen_start":30480,"node":59,"role":"declaration","source":0,"src_end":5569,"src_start":5271},{"artifact":1,"gen_end":31150,"gen_start":30826,"node":60,"role":"declaration","source":0,"src_end":5723,"src_start":5571},{"artifact":1,"gen_end":31418,"gen_start":31150,"node":61,"role":"declaration","source":0,"src_end":5927,"src_start":5725},{"artifact":1,"gen_end":31775,"gen_start":31418,"node":62,"role":"declaration","source":0,"src_end":6207,"src_start":5929},{"artifact":1,"gen_end":32131,"gen_start":31775,"node":63,"role":"declaration","source":0,"src_end":6521,"src_start":6209},{"artifact":1,"gen_end":32464,"gen_start":32131,"node":64,"role":"declaration","source":0,"src_end":6801,"src_start":6523},{"artifact":1,"gen_end":51452,"gen_start":32464,"node":65,"role":"declaration","source":0,"src_end":7410,"src_start":6803},{"artifact":1,"gen_end":71336,"gen_start":51452,"node":66,"role":"declaration","source":0,"src_end":8079,"src_start":7412},{"artifact":1,"gen_end":90352,"gen_start":71336,"node":67,"role":"declaration","source":0,"src_end":8649,"src_start":8081},{"artifact":1,"gen_end":90367,"gen_start":90352,"node":34,"role":"declaration","source":0,"src_end":8685,"src_start":0}],"module":"PlannerOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-latex-module"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/PlannerOracle.lex.tex","sha256":"8579b13fcc26a5bdd3323388f400d1b0b805359f96fe4beea29b26bbaa79f50b"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/ReasoningFixtures.map.json b/compiler/expected/build/maps/LexLeanTarget/ReasoningFixtures.map.json index 1c0f0add7..8f7955ca4 100644 --- a/compiler/expected/build/maps/LexLeanTarget/ReasoningFixtures.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/ReasoningFixtures.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ReasoningFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ReasoningFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":510,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":0,"gen_end":1242,"gen_start":510,"node":1,"role":"declaration","source":0,"src_end":1039,"src_start":331},{"artifact":0,"gen_end":2552,"gen_start":1242,"node":2,"role":"declaration","source":0,"src_end":2029,"src_start":1041},{"artifact":0,"gen_end":2840,"gen_start":2552,"node":3,"role":"declaration","source":0,"src_end":2350,"src_start":2031},{"artifact":0,"gen_end":3461,"gen_start":2840,"node":4,"role":"declaration","source":0,"src_end":2845,"src_start":2352},{"artifact":0,"gen_end":3743,"gen_start":3461,"node":5,"role":"declaration","source":0,"src_end":3160,"src_start":2847},{"artifact":0,"gen_end":4098,"gen_start":3743,"node":6,"role":"declaration","source":0,"src_end":3469,"src_start":3162},{"artifact":0,"gen_end":4390,"gen_start":4098,"node":7,"role":"declaration","source":0,"src_end":3794,"src_start":3471},{"artifact":0,"gen_end":4741,"gen_start":4390,"node":8,"role":"declaration","source":0,"src_end":4099,"src_start":3796},{"artifact":0,"gen_end":5025,"gen_start":4741,"node":9,"role":"declaration","source":0,"src_end":4416,"src_start":4101},{"artifact":0,"gen_end":28222,"gen_start":5025,"node":10,"role":"declaration","source":0,"src_end":22330,"src_start":4418},{"artifact":0,"gen_end":28475,"gen_start":28222,"node":11,"role":"declaration","source":0,"src_end":22611,"src_start":22332},{"artifact":0,"gen_end":29278,"gen_start":28475,"node":12,"role":"declaration","source":0,"src_end":23361,"src_start":22613},{"artifact":0,"gen_end":30654,"gen_start":29278,"node":13,"role":"declaration","source":0,"src_end":24693,"src_start":23363},{"artifact":0,"gen_end":53850,"gen_start":30654,"node":14,"role":"declaration","source":0,"src_end":42606,"src_start":24695},{"artifact":0,"gen_end":54100,"gen_start":53850,"node":15,"role":"declaration","source":0,"src_end":42884,"src_start":42608},{"artifact":0,"gen_end":55077,"gen_start":54100,"node":16,"role":"declaration","source":0,"src_end":43752,"src_start":42886},{"artifact":0,"gen_end":56444,"gen_start":55077,"node":17,"role":"declaration","source":0,"src_end":45075,"src_start":43754},{"artifact":0,"gen_end":75337,"gen_start":56444,"node":18,"role":"declaration","source":0,"src_end":59906,"src_start":45077},{"artifact":0,"gen_end":75778,"gen_start":75337,"node":19,"role":"declaration","source":0,"src_end":60351,"src_start":59908},{"artifact":0,"gen_end":76284,"gen_start":75778,"node":20,"role":"declaration","source":0,"src_end":60866,"src_start":60353},{"artifact":0,"gen_end":78096,"gen_start":76284,"node":21,"role":"declaration","source":0,"src_end":62617,"src_start":60868},{"artifact":0,"gen_end":98623,"gen_start":78096,"node":22,"role":"declaration","source":0,"src_end":78672,"src_start":62619},{"artifact":0,"gen_end":99072,"gen_start":98623,"node":23,"role":"declaration","source":0,"src_end":79125,"src_start":78674},{"artifact":0,"gen_end":99586,"gen_start":99072,"node":24,"role":"declaration","source":0,"src_end":79648,"src_start":79127},{"artifact":0,"gen_end":101406,"gen_start":99586,"node":25,"role":"declaration","source":0,"src_end":81407,"src_start":79650},{"artifact":0,"gen_end":122020,"gen_start":101406,"node":26,"role":"declaration","source":0,"src_end":97540,"src_start":81409},{"artifact":0,"gen_end":122463,"gen_start":122020,"node":27,"role":"declaration","source":0,"src_end":97987,"src_start":97542},{"artifact":0,"gen_end":122971,"gen_start":122463,"node":28,"role":"declaration","source":0,"src_end":98504,"src_start":97989},{"artifact":0,"gen_end":124785,"gen_start":122971,"node":29,"role":"declaration","source":0,"src_end":100257,"src_start":98506},{"artifact":0,"gen_end":179944,"gen_start":124785,"node":30,"role":"declaration","source":0,"src_end":142701,"src_start":100259},{"artifact":0,"gen_end":180533,"gen_start":179944,"node":31,"role":"declaration","source":0,"src_end":143259,"src_start":142703},{"artifact":0,"gen_end":180749,"gen_start":180533,"node":32,"role":"declaration","source":0,"src_end":143548,"src_start":143261},{"artifact":0,"gen_end":181290,"gen_start":180749,"node":33,"role":"declaration","source":0,"src_end":144134,"src_start":143550},{"artifact":0,"gen_end":236448,"gen_start":181290,"node":34,"role":"declaration","source":0,"src_end":186577,"src_start":144136},{"artifact":0,"gen_end":237034,"gen_start":236448,"node":35,"role":"declaration","source":0,"src_end":187132,"src_start":186579},{"artifact":0,"gen_end":237247,"gen_start":237034,"node":36,"role":"declaration","source":0,"src_end":187418,"src_start":187134},{"artifact":0,"gen_end":237784,"gen_start":237247,"node":37,"role":"declaration","source":0,"src_end":188000,"src_start":187420},{"artifact":0,"gen_end":314696,"gen_start":237784,"node":38,"role":"declaration","source":0,"src_end":247140,"src_start":188002},{"artifact":0,"gen_end":314945,"gen_start":314696,"node":39,"role":"declaration","source":0,"src_end":247417,"src_start":247142},{"artifact":0,"gen_end":316098,"gen_start":314945,"node":40,"role":"declaration","source":0,"src_end":248414,"src_start":247419},{"artifact":0,"gen_end":317566,"gen_start":316098,"node":41,"role":"declaration","source":0,"src_end":249857,"src_start":248416},{"artifact":0,"gen_end":394478,"gen_start":317566,"node":42,"role":"declaration","source":0,"src_end":308997,"src_start":249859},{"artifact":0,"gen_end":394727,"gen_start":394478,"node":43,"role":"declaration","source":0,"src_end":309274,"src_start":308999},{"artifact":0,"gen_end":395534,"gen_start":394727,"node":44,"role":"declaration","source":0,"src_end":310028,"src_start":309276},{"artifact":0,"gen_end":397003,"gen_start":395534,"node":45,"role":"declaration","source":0,"src_end":311472,"src_start":310030},{"artifact":0,"gen_end":453293,"gen_start":397003,"node":46,"role":"declaration","source":0,"src_end":354793,"src_start":311474},{"artifact":0,"gen_end":453892,"gen_start":453293,"node":47,"role":"declaration","source":0,"src_end":355361,"src_start":354795},{"artifact":0,"gen_end":454214,"gen_start":453892,"node":48,"role":"declaration","source":0,"src_end":355738,"src_start":355363},{"artifact":0,"gen_end":454770,"gen_start":454214,"node":49,"role":"declaration","source":0,"src_end":356339,"src_start":355740},{"artifact":0,"gen_end":511059,"gen_start":454770,"node":50,"role":"declaration","source":0,"src_end":399659,"src_start":356341},{"artifact":0,"gen_end":511656,"gen_start":511059,"node":51,"role":"declaration","source":0,"src_end":400225,"src_start":399661},{"artifact":0,"gen_end":511975,"gen_start":511656,"node":52,"role":"declaration","source":0,"src_end":400599,"src_start":400227},{"artifact":0,"gen_end":512529,"gen_start":511975,"node":53,"role":"declaration","source":0,"src_end":401198,"src_start":400601},{"artifact":0,"gen_end":561947,"gen_start":512529,"node":54,"role":"declaration","source":0,"src_end":439258,"src_start":401200},{"artifact":0,"gen_end":562199,"gen_start":561947,"node":55,"role":"declaration","source":0,"src_end":439538,"src_start":439260},{"artifact":0,"gen_end":563001,"gen_start":562199,"node":56,"role":"declaration","source":0,"src_end":440287,"src_start":439540},{"artifact":0,"gen_end":564403,"gen_start":563001,"node":57,"role":"declaration","source":0,"src_end":441669,"src_start":440289},{"artifact":0,"gen_end":613823,"gen_start":564403,"node":58,"role":"declaration","source":0,"src_end":479731,"src_start":441671},{"artifact":0,"gen_end":614081,"gen_start":613823,"node":59,"role":"declaration","source":0,"src_end":480017,"src_start":479733},{"artifact":0,"gen_end":614890,"gen_start":614081,"node":60,"role":"declaration","source":0,"src_end":480773,"src_start":480019},{"artifact":0,"gen_end":616311,"gen_start":614890,"node":61,"role":"declaration","source":0,"src_end":482174,"src_start":480775},{"artifact":0,"gen_end":665730,"gen_start":616311,"node":62,"role":"declaration","source":0,"src_end":520235,"src_start":482176},{"artifact":0,"gen_end":665985,"gen_start":665730,"node":63,"role":"declaration","source":0,"src_end":520518,"src_start":520237},{"artifact":0,"gen_end":666968,"gen_start":665985,"node":64,"role":"declaration","source":0,"src_end":521392,"src_start":520520},{"artifact":0,"gen_end":668380,"gen_start":666968,"node":65,"role":"declaration","source":0,"src_end":522784,"src_start":521394},{"artifact":0,"gen_end":699337,"gen_start":668380,"node":66,"role":"declaration","source":0,"src_end":546611,"src_start":522786},{"artifact":0,"gen_end":699669,"gen_start":699337,"node":67,"role":"declaration","source":0,"src_end":546953,"src_start":546613},{"artifact":0,"gen_end":699876,"gen_start":699669,"node":68,"role":"declaration","source":0,"src_end":547233,"src_start":546955},{"artifact":0,"gen_end":700267,"gen_start":699876,"node":69,"role":"declaration","source":0,"src_end":547679,"src_start":547235},{"artifact":0,"gen_end":758400,"gen_start":700267,"node":70,"role":"declaration","source":0,"src_end":592392,"src_start":547681},{"artifact":0,"gen_end":758991,"gen_start":758400,"node":71,"role":"declaration","source":0,"src_end":592952,"src_start":592394},{"artifact":0,"gen_end":759209,"gen_start":758991,"node":72,"role":"declaration","source":0,"src_end":593243,"src_start":592954},{"artifact":0,"gen_end":759757,"gen_start":759209,"node":73,"role":"declaration","source":0,"src_end":593836,"src_start":593245},{"artifact":0,"gen_end":833886,"gen_start":759757,"node":74,"role":"declaration","source":0,"src_end":650834,"src_start":593838},{"artifact":0,"gen_end":834479,"gen_start":833886,"node":75,"role":"declaration","source":0,"src_end":651396,"src_start":650836},{"artifact":0,"gen_end":835946,"gen_start":834479,"node":76,"role":"declaration","source":0,"src_end":652571,"src_start":651398},{"artifact":0,"gen_end":837191,"gen_start":835946,"node":77,"role":"declaration","source":0,"src_end":653786,"src_start":652573},{"artifact":0,"gen_end":895323,"gen_start":837191,"node":78,"role":"declaration","source":0,"src_end":698498,"src_start":653788},{"artifact":0,"gen_end":895911,"gen_start":895323,"node":79,"role":"declaration","source":0,"src_end":699055,"src_start":698500},{"artifact":0,"gen_end":896126,"gen_start":895911,"node":80,"role":"declaration","source":0,"src_end":699343,"src_start":699057},{"artifact":0,"gen_end":896670,"gen_start":896126,"node":81,"role":"declaration","source":0,"src_end":699932,"src_start":699345},{"artifact":0,"gen_end":896707,"gen_start":896670,"node":0,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":82,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":1,"gen_end":1102,"gen_start":134,"node":83,"role":"declaration","source":0,"src_end":1039,"src_start":331},{"artifact":1,"gen_end":2594,"gen_start":1102,"node":84,"role":"declaration","source":0,"src_end":2029,"src_start":1041},{"artifact":1,"gen_end":3079,"gen_start":2594,"node":85,"role":"declaration","source":0,"src_end":2350,"src_start":2031},{"artifact":1,"gen_end":3882,"gen_start":3079,"node":86,"role":"declaration","source":0,"src_end":2845,"src_start":2352},{"artifact":1,"gen_end":4361,"gen_start":3882,"node":87,"role":"declaration","source":0,"src_end":3160,"src_start":2847},{"artifact":1,"gen_end":4898,"gen_start":4361,"node":88,"role":"declaration","source":0,"src_end":3469,"src_start":3162},{"artifact":1,"gen_end":5387,"gen_start":4898,"node":89,"role":"declaration","source":0,"src_end":3794,"src_start":3471},{"artifact":1,"gen_end":5920,"gen_start":5387,"node":90,"role":"declaration","source":0,"src_end":4099,"src_start":3796},{"artifact":1,"gen_end":6401,"gen_start":5920,"node":91,"role":"declaration","source":0,"src_end":4416,"src_start":4101},{"artifact":1,"gen_end":29826,"gen_start":6401,"node":92,"role":"declaration","source":0,"src_end":22330,"src_start":4418},{"artifact":1,"gen_end":30266,"gen_start":29826,"node":93,"role":"declaration","source":0,"src_end":22611,"src_start":22332},{"artifact":1,"gen_end":31219,"gen_start":30266,"node":94,"role":"declaration","source":0,"src_end":23361,"src_start":22613},{"artifact":1,"gen_end":32745,"gen_start":31219,"node":95,"role":"declaration","source":0,"src_end":24693,"src_start":23363},{"artifact":1,"gen_end":56169,"gen_start":32745,"node":96,"role":"declaration","source":0,"src_end":42606,"src_start":24695},{"artifact":1,"gen_end":56606,"gen_start":56169,"node":97,"role":"declaration","source":0,"src_end":42884,"src_start":42608},{"artifact":1,"gen_end":57733,"gen_start":56606,"node":98,"role":"declaration","source":0,"src_end":43752,"src_start":42886},{"artifact":1,"gen_end":59250,"gen_start":57733,"node":99,"role":"declaration","source":0,"src_end":45075,"src_start":43754},{"artifact":1,"gen_end":78295,"gen_start":59250,"node":100,"role":"declaration","source":0,"src_end":59906,"src_start":45077},{"artifact":1,"gen_end":78923,"gen_start":78295,"node":101,"role":"declaration","source":0,"src_end":60351,"src_start":59908},{"artifact":1,"gen_end":79579,"gen_start":78923,"node":102,"role":"declaration","source":0,"src_end":60866,"src_start":60353},{"artifact":1,"gen_end":81556,"gen_start":79579,"node":103,"role":"declaration","source":0,"src_end":62617,"src_start":60868},{"artifact":1,"gen_end":102235,"gen_start":81556,"node":104,"role":"declaration","source":0,"src_end":78672,"src_start":62619},{"artifact":1,"gen_end":102871,"gen_start":102235,"node":105,"role":"declaration","source":0,"src_end":79125,"src_start":78674},{"artifact":1,"gen_end":103535,"gen_start":102871,"node":106,"role":"declaration","source":0,"src_end":79648,"src_start":79127},{"artifact":1,"gen_end":105520,"gen_start":103535,"node":107,"role":"declaration","source":0,"src_end":81407,"src_start":79650},{"artifact":1,"gen_end":126322,"gen_start":105520,"node":108,"role":"declaration","source":0,"src_end":97540,"src_start":81409},{"artifact":1,"gen_end":126952,"gen_start":126322,"node":109,"role":"declaration","source":0,"src_end":97987,"src_start":97542},{"artifact":1,"gen_end":127610,"gen_start":126952,"node":110,"role":"declaration","source":0,"src_end":98504,"src_start":97989},{"artifact":1,"gen_end":129589,"gen_start":127610,"node":111,"role":"declaration","source":0,"src_end":100257,"src_start":98506},{"artifact":1,"gen_end":185074,"gen_start":129589,"node":112,"role":"declaration","source":0,"src_end":142701,"src_start":100259},{"artifact":1,"gen_end":185850,"gen_start":185074,"node":113,"role":"declaration","source":0,"src_end":143259,"src_start":142703},{"artifact":1,"gen_end":186216,"gen_start":185850,"node":114,"role":"declaration","source":0,"src_end":143548,"src_start":143261},{"artifact":1,"gen_end":186909,"gen_start":186216,"node":115,"role":"declaration","source":0,"src_end":144134,"src_start":143550},{"artifact":1,"gen_end":242393,"gen_start":186909,"node":116,"role":"declaration","source":0,"src_end":186577,"src_start":144136},{"artifact":1,"gen_end":243166,"gen_start":242393,"node":117,"role":"declaration","source":0,"src_end":187132,"src_start":186579},{"artifact":1,"gen_end":243529,"gen_start":243166,"node":118,"role":"declaration","source":0,"src_end":187418,"src_start":187134},{"artifact":1,"gen_end":244218,"gen_start":243529,"node":119,"role":"declaration","source":0,"src_end":188000,"src_start":187420},{"artifact":1,"gen_end":321664,"gen_start":244218,"node":120,"role":"declaration","source":0,"src_end":247140,"src_start":188002},{"artifact":1,"gen_end":322100,"gen_start":321664,"node":121,"role":"declaration","source":0,"src_end":247417,"src_start":247142},{"artifact":1,"gen_end":323403,"gen_start":322100,"node":122,"role":"declaration","source":0,"src_end":248414,"src_start":247419},{"artifact":1,"gen_end":325021,"gen_start":323403,"node":123,"role":"declaration","source":0,"src_end":249857,"src_start":248416},{"artifact":1,"gen_end":402467,"gen_start":325021,"node":124,"role":"declaration","source":0,"src_end":308997,"src_start":249859},{"artifact":1,"gen_end":402903,"gen_start":402467,"node":125,"role":"declaration","source":0,"src_end":309274,"src_start":308999},{"artifact":1,"gen_end":403860,"gen_start":402903,"node":126,"role":"declaration","source":0,"src_end":310028,"src_start":309276},{"artifact":1,"gen_end":405479,"gen_start":403860,"node":127,"role":"declaration","source":0,"src_end":311472,"src_start":310030},{"artifact":1,"gen_end":462109,"gen_start":405479,"node":128,"role":"declaration","source":0,"src_end":354793,"src_start":311474},{"artifact":1,"gen_end":462895,"gen_start":462109,"node":129,"role":"declaration","source":0,"src_end":355361,"src_start":354795},{"artifact":1,"gen_end":463367,"gen_start":462895,"node":130,"role":"declaration","source":0,"src_end":355738,"src_start":355363},{"artifact":1,"gen_end":464075,"gen_start":463367,"node":131,"role":"declaration","source":0,"src_end":356339,"src_start":355740},{"artifact":1,"gen_end":520704,"gen_start":464075,"node":132,"role":"declaration","source":0,"src_end":399659,"src_start":356341},{"artifact":1,"gen_end":521488,"gen_start":520704,"node":133,"role":"declaration","source":0,"src_end":400225,"src_start":399661},{"artifact":1,"gen_end":521957,"gen_start":521488,"node":134,"role":"declaration","source":0,"src_end":400599,"src_start":400227},{"artifact":1,"gen_end":522663,"gen_start":521957,"node":135,"role":"declaration","source":0,"src_end":401198,"src_start":400601},{"artifact":1,"gen_end":572493,"gen_start":522663,"node":136,"role":"declaration","source":0,"src_end":439258,"src_start":401200},{"artifact":1,"gen_end":572932,"gen_start":572493,"node":137,"role":"declaration","source":0,"src_end":439538,"src_start":439260},{"artifact":1,"gen_end":573884,"gen_start":572932,"node":138,"role":"declaration","source":0,"src_end":440287,"src_start":439540},{"artifact":1,"gen_end":575436,"gen_start":573884,"node":139,"role":"declaration","source":0,"src_end":441669,"src_start":440289},{"artifact":1,"gen_end":625268,"gen_start":575436,"node":140,"role":"declaration","source":0,"src_end":479731,"src_start":441671},{"artifact":1,"gen_end":625713,"gen_start":625268,"node":141,"role":"declaration","source":0,"src_end":480017,"src_start":479733},{"artifact":1,"gen_end":626672,"gen_start":625713,"node":142,"role":"declaration","source":0,"src_end":480773,"src_start":480019},{"artifact":1,"gen_end":628243,"gen_start":626672,"node":143,"role":"declaration","source":0,"src_end":482174,"src_start":480775},{"artifact":1,"gen_end":678074,"gen_start":628243,"node":144,"role":"declaration","source":0,"src_end":520235,"src_start":482176},{"artifact":1,"gen_end":678516,"gen_start":678074,"node":145,"role":"declaration","source":0,"src_end":520518,"src_start":520237},{"artifact":1,"gen_end":679649,"gen_start":678516,"node":146,"role":"declaration","source":0,"src_end":521392,"src_start":520520},{"artifact":1,"gen_end":681211,"gen_start":679649,"node":147,"role":"declaration","source":0,"src_end":522784,"src_start":521394},{"artifact":1,"gen_end":712500,"gen_start":681211,"node":148,"role":"declaration","source":0,"src_end":546611,"src_start":522786},{"artifact":1,"gen_end":713019,"gen_start":712500,"node":149,"role":"declaration","source":0,"src_end":546953,"src_start":546613},{"artifact":1,"gen_end":713376,"gen_start":713019,"node":150,"role":"declaration","source":0,"src_end":547233,"src_start":546955},{"artifact":1,"gen_end":713917,"gen_start":713376,"node":151,"role":"declaration","source":0,"src_end":547679,"src_start":547235},{"artifact":1,"gen_end":772390,"gen_start":713917,"node":152,"role":"declaration","source":0,"src_end":592392,"src_start":547681},{"artifact":1,"gen_end":773168,"gen_start":772390,"node":153,"role":"declaration","source":0,"src_end":592952,"src_start":592394},{"artifact":1,"gen_end":773536,"gen_start":773168,"node":154,"role":"declaration","source":0,"src_end":593243,"src_start":592954},{"artifact":1,"gen_end":774236,"gen_start":773536,"node":155,"role":"declaration","source":0,"src_end":593836,"src_start":593245},{"artifact":1,"gen_end":848763,"gen_start":774236,"node":156,"role":"declaration","source":0,"src_end":650834,"src_start":593838},{"artifact":1,"gen_end":849543,"gen_start":848763,"node":157,"role":"declaration","source":0,"src_end":651396,"src_start":650836},{"artifact":1,"gen_end":851160,"gen_start":849543,"node":158,"role":"declaration","source":0,"src_end":652571,"src_start":651398},{"artifact":1,"gen_end":852561,"gen_start":851160,"node":159,"role":"declaration","source":0,"src_end":653786,"src_start":652573},{"artifact":1,"gen_end":911033,"gen_start":852561,"node":160,"role":"declaration","source":0,"src_end":698498,"src_start":653788},{"artifact":1,"gen_end":911808,"gen_start":911033,"node":161,"role":"declaration","source":0,"src_end":699055,"src_start":698500},{"artifact":1,"gen_end":912173,"gen_start":911808,"node":162,"role":"declaration","source":0,"src_end":699343,"src_start":699057},{"artifact":1,"gen_end":912869,"gen_start":912173,"node":163,"role":"declaration","source":0,"src_end":699932,"src_start":699345},{"artifact":1,"gen_end":912884,"gen_start":912869,"node":82,"role":"declaration","source":0,"src_end":699968,"src_start":0}],"module":"ReasoningFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-latex-module"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/ReasoningFixtures.lex.tex","sha256":"21de0c44ebce81bb7bb1b05a6e29815cc2e6c19a58a4c85459110bf3fd1dee9c"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ReasoningFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ReasoningFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":510,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":0,"gen_end":1242,"gen_start":510,"node":1,"role":"declaration","source":0,"src_end":1039,"src_start":331},{"artifact":0,"gen_end":2552,"gen_start":1242,"node":2,"role":"declaration","source":0,"src_end":2029,"src_start":1041},{"artifact":0,"gen_end":2840,"gen_start":2552,"node":3,"role":"declaration","source":0,"src_end":2350,"src_start":2031},{"artifact":0,"gen_end":3461,"gen_start":2840,"node":4,"role":"declaration","source":0,"src_end":2845,"src_start":2352},{"artifact":0,"gen_end":3743,"gen_start":3461,"node":5,"role":"declaration","source":0,"src_end":3160,"src_start":2847},{"artifact":0,"gen_end":4098,"gen_start":3743,"node":6,"role":"declaration","source":0,"src_end":3469,"src_start":3162},{"artifact":0,"gen_end":4390,"gen_start":4098,"node":7,"role":"declaration","source":0,"src_end":3794,"src_start":3471},{"artifact":0,"gen_end":4741,"gen_start":4390,"node":8,"role":"declaration","source":0,"src_end":4099,"src_start":3796},{"artifact":0,"gen_end":5025,"gen_start":4741,"node":9,"role":"declaration","source":0,"src_end":4416,"src_start":4101},{"artifact":0,"gen_end":28222,"gen_start":5025,"node":10,"role":"declaration","source":0,"src_end":22330,"src_start":4418},{"artifact":0,"gen_end":28475,"gen_start":28222,"node":11,"role":"declaration","source":0,"src_end":22611,"src_start":22332},{"artifact":0,"gen_end":29278,"gen_start":28475,"node":12,"role":"declaration","source":0,"src_end":23361,"src_start":22613},{"artifact":0,"gen_end":30654,"gen_start":29278,"node":13,"role":"declaration","source":0,"src_end":24693,"src_start":23363},{"artifact":0,"gen_end":53850,"gen_start":30654,"node":14,"role":"declaration","source":0,"src_end":42606,"src_start":24695},{"artifact":0,"gen_end":54100,"gen_start":53850,"node":15,"role":"declaration","source":0,"src_end":42884,"src_start":42608},{"artifact":0,"gen_end":55077,"gen_start":54100,"node":16,"role":"declaration","source":0,"src_end":43752,"src_start":42886},{"artifact":0,"gen_end":56444,"gen_start":55077,"node":17,"role":"declaration","source":0,"src_end":45075,"src_start":43754},{"artifact":0,"gen_end":75337,"gen_start":56444,"node":18,"role":"declaration","source":0,"src_end":59906,"src_start":45077},{"artifact":0,"gen_end":75778,"gen_start":75337,"node":19,"role":"declaration","source":0,"src_end":60351,"src_start":59908},{"artifact":0,"gen_end":76284,"gen_start":75778,"node":20,"role":"declaration","source":0,"src_end":60866,"src_start":60353},{"artifact":0,"gen_end":78096,"gen_start":76284,"node":21,"role":"declaration","source":0,"src_end":62617,"src_start":60868},{"artifact":0,"gen_end":98623,"gen_start":78096,"node":22,"role":"declaration","source":0,"src_end":78672,"src_start":62619},{"artifact":0,"gen_end":99072,"gen_start":98623,"node":23,"role":"declaration","source":0,"src_end":79125,"src_start":78674},{"artifact":0,"gen_end":99586,"gen_start":99072,"node":24,"role":"declaration","source":0,"src_end":79648,"src_start":79127},{"artifact":0,"gen_end":101406,"gen_start":99586,"node":25,"role":"declaration","source":0,"src_end":81407,"src_start":79650},{"artifact":0,"gen_end":122020,"gen_start":101406,"node":26,"role":"declaration","source":0,"src_end":97540,"src_start":81409},{"artifact":0,"gen_end":122463,"gen_start":122020,"node":27,"role":"declaration","source":0,"src_end":97987,"src_start":97542},{"artifact":0,"gen_end":122971,"gen_start":122463,"node":28,"role":"declaration","source":0,"src_end":98504,"src_start":97989},{"artifact":0,"gen_end":124785,"gen_start":122971,"node":29,"role":"declaration","source":0,"src_end":100257,"src_start":98506},{"artifact":0,"gen_end":179944,"gen_start":124785,"node":30,"role":"declaration","source":0,"src_end":142701,"src_start":100259},{"artifact":0,"gen_end":180533,"gen_start":179944,"node":31,"role":"declaration","source":0,"src_end":143259,"src_start":142703},{"artifact":0,"gen_end":180749,"gen_start":180533,"node":32,"role":"declaration","source":0,"src_end":143548,"src_start":143261},{"artifact":0,"gen_end":181290,"gen_start":180749,"node":33,"role":"declaration","source":0,"src_end":144134,"src_start":143550},{"artifact":0,"gen_end":236448,"gen_start":181290,"node":34,"role":"declaration","source":0,"src_end":186577,"src_start":144136},{"artifact":0,"gen_end":237034,"gen_start":236448,"node":35,"role":"declaration","source":0,"src_end":187132,"src_start":186579},{"artifact":0,"gen_end":237247,"gen_start":237034,"node":36,"role":"declaration","source":0,"src_end":187418,"src_start":187134},{"artifact":0,"gen_end":237784,"gen_start":237247,"node":37,"role":"declaration","source":0,"src_end":188000,"src_start":187420},{"artifact":0,"gen_end":314696,"gen_start":237784,"node":38,"role":"declaration","source":0,"src_end":247140,"src_start":188002},{"artifact":0,"gen_end":314945,"gen_start":314696,"node":39,"role":"declaration","source":0,"src_end":247417,"src_start":247142},{"artifact":0,"gen_end":316098,"gen_start":314945,"node":40,"role":"declaration","source":0,"src_end":248414,"src_start":247419},{"artifact":0,"gen_end":317566,"gen_start":316098,"node":41,"role":"declaration","source":0,"src_end":249857,"src_start":248416},{"artifact":0,"gen_end":394478,"gen_start":317566,"node":42,"role":"declaration","source":0,"src_end":308997,"src_start":249859},{"artifact":0,"gen_end":394727,"gen_start":394478,"node":43,"role":"declaration","source":0,"src_end":309274,"src_start":308999},{"artifact":0,"gen_end":395534,"gen_start":394727,"node":44,"role":"declaration","source":0,"src_end":310028,"src_start":309276},{"artifact":0,"gen_end":397003,"gen_start":395534,"node":45,"role":"declaration","source":0,"src_end":311472,"src_start":310030},{"artifact":0,"gen_end":453293,"gen_start":397003,"node":46,"role":"declaration","source":0,"src_end":354793,"src_start":311474},{"artifact":0,"gen_end":453892,"gen_start":453293,"node":47,"role":"declaration","source":0,"src_end":355361,"src_start":354795},{"artifact":0,"gen_end":454214,"gen_start":453892,"node":48,"role":"declaration","source":0,"src_end":355738,"src_start":355363},{"artifact":0,"gen_end":454770,"gen_start":454214,"node":49,"role":"declaration","source":0,"src_end":356339,"src_start":355740},{"artifact":0,"gen_end":511059,"gen_start":454770,"node":50,"role":"declaration","source":0,"src_end":399659,"src_start":356341},{"artifact":0,"gen_end":511656,"gen_start":511059,"node":51,"role":"declaration","source":0,"src_end":400225,"src_start":399661},{"artifact":0,"gen_end":511975,"gen_start":511656,"node":52,"role":"declaration","source":0,"src_end":400599,"src_start":400227},{"artifact":0,"gen_end":512529,"gen_start":511975,"node":53,"role":"declaration","source":0,"src_end":401198,"src_start":400601},{"artifact":0,"gen_end":561947,"gen_start":512529,"node":54,"role":"declaration","source":0,"src_end":439258,"src_start":401200},{"artifact":0,"gen_end":562199,"gen_start":561947,"node":55,"role":"declaration","source":0,"src_end":439538,"src_start":439260},{"artifact":0,"gen_end":563001,"gen_start":562199,"node":56,"role":"declaration","source":0,"src_end":440287,"src_start":439540},{"artifact":0,"gen_end":564403,"gen_start":563001,"node":57,"role":"declaration","source":0,"src_end":441669,"src_start":440289},{"artifact":0,"gen_end":613823,"gen_start":564403,"node":58,"role":"declaration","source":0,"src_end":479731,"src_start":441671},{"artifact":0,"gen_end":614081,"gen_start":613823,"node":59,"role":"declaration","source":0,"src_end":480017,"src_start":479733},{"artifact":0,"gen_end":614890,"gen_start":614081,"node":60,"role":"declaration","source":0,"src_end":480773,"src_start":480019},{"artifact":0,"gen_end":616311,"gen_start":614890,"node":61,"role":"declaration","source":0,"src_end":482174,"src_start":480775},{"artifact":0,"gen_end":665730,"gen_start":616311,"node":62,"role":"declaration","source":0,"src_end":520235,"src_start":482176},{"artifact":0,"gen_end":665985,"gen_start":665730,"node":63,"role":"declaration","source":0,"src_end":520518,"src_start":520237},{"artifact":0,"gen_end":666968,"gen_start":665985,"node":64,"role":"declaration","source":0,"src_end":521392,"src_start":520520},{"artifact":0,"gen_end":668380,"gen_start":666968,"node":65,"role":"declaration","source":0,"src_end":522784,"src_start":521394},{"artifact":0,"gen_end":699337,"gen_start":668380,"node":66,"role":"declaration","source":0,"src_end":546611,"src_start":522786},{"artifact":0,"gen_end":699669,"gen_start":699337,"node":67,"role":"declaration","source":0,"src_end":546953,"src_start":546613},{"artifact":0,"gen_end":699876,"gen_start":699669,"node":68,"role":"declaration","source":0,"src_end":547233,"src_start":546955},{"artifact":0,"gen_end":700267,"gen_start":699876,"node":69,"role":"declaration","source":0,"src_end":547679,"src_start":547235},{"artifact":0,"gen_end":758400,"gen_start":700267,"node":70,"role":"declaration","source":0,"src_end":592392,"src_start":547681},{"artifact":0,"gen_end":758991,"gen_start":758400,"node":71,"role":"declaration","source":0,"src_end":592952,"src_start":592394},{"artifact":0,"gen_end":759209,"gen_start":758991,"node":72,"role":"declaration","source":0,"src_end":593243,"src_start":592954},{"artifact":0,"gen_end":759757,"gen_start":759209,"node":73,"role":"declaration","source":0,"src_end":593836,"src_start":593245},{"artifact":0,"gen_end":833886,"gen_start":759757,"node":74,"role":"declaration","source":0,"src_end":650834,"src_start":593838},{"artifact":0,"gen_end":834479,"gen_start":833886,"node":75,"role":"declaration","source":0,"src_end":651396,"src_start":650836},{"artifact":0,"gen_end":835946,"gen_start":834479,"node":76,"role":"declaration","source":0,"src_end":652571,"src_start":651398},{"artifact":0,"gen_end":837191,"gen_start":835946,"node":77,"role":"declaration","source":0,"src_end":653786,"src_start":652573},{"artifact":0,"gen_end":895323,"gen_start":837191,"node":78,"role":"declaration","source":0,"src_end":698498,"src_start":653788},{"artifact":0,"gen_end":895911,"gen_start":895323,"node":79,"role":"declaration","source":0,"src_end":699055,"src_start":698500},{"artifact":0,"gen_end":896126,"gen_start":895911,"node":80,"role":"declaration","source":0,"src_end":699343,"src_start":699057},{"artifact":0,"gen_end":896670,"gen_start":896126,"node":81,"role":"declaration","source":0,"src_end":699932,"src_start":699345},{"artifact":0,"gen_end":896707,"gen_start":896670,"node":0,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":82,"role":"declaration","source":0,"src_end":699968,"src_start":0},{"artifact":1,"gen_end":1102,"gen_start":134,"node":83,"role":"declaration","source":0,"src_end":1039,"src_start":331},{"artifact":1,"gen_end":2594,"gen_start":1102,"node":84,"role":"declaration","source":0,"src_end":2029,"src_start":1041},{"artifact":1,"gen_end":3079,"gen_start":2594,"node":85,"role":"declaration","source":0,"src_end":2350,"src_start":2031},{"artifact":1,"gen_end":3882,"gen_start":3079,"node":86,"role":"declaration","source":0,"src_end":2845,"src_start":2352},{"artifact":1,"gen_end":4361,"gen_start":3882,"node":87,"role":"declaration","source":0,"src_end":3160,"src_start":2847},{"artifact":1,"gen_end":4898,"gen_start":4361,"node":88,"role":"declaration","source":0,"src_end":3469,"src_start":3162},{"artifact":1,"gen_end":5387,"gen_start":4898,"node":89,"role":"declaration","source":0,"src_end":3794,"src_start":3471},{"artifact":1,"gen_end":5920,"gen_start":5387,"node":90,"role":"declaration","source":0,"src_end":4099,"src_start":3796},{"artifact":1,"gen_end":6401,"gen_start":5920,"node":91,"role":"declaration","source":0,"src_end":4416,"src_start":4101},{"artifact":1,"gen_end":29826,"gen_start":6401,"node":92,"role":"declaration","source":0,"src_end":22330,"src_start":4418},{"artifact":1,"gen_end":30266,"gen_start":29826,"node":93,"role":"declaration","source":0,"src_end":22611,"src_start":22332},{"artifact":1,"gen_end":31219,"gen_start":30266,"node":94,"role":"declaration","source":0,"src_end":23361,"src_start":22613},{"artifact":1,"gen_end":32745,"gen_start":31219,"node":95,"role":"declaration","source":0,"src_end":24693,"src_start":23363},{"artifact":1,"gen_end":56169,"gen_start":32745,"node":96,"role":"declaration","source":0,"src_end":42606,"src_start":24695},{"artifact":1,"gen_end":56606,"gen_start":56169,"node":97,"role":"declaration","source":0,"src_end":42884,"src_start":42608},{"artifact":1,"gen_end":57733,"gen_start":56606,"node":98,"role":"declaration","source":0,"src_end":43752,"src_start":42886},{"artifact":1,"gen_end":59250,"gen_start":57733,"node":99,"role":"declaration","source":0,"src_end":45075,"src_start":43754},{"artifact":1,"gen_end":78295,"gen_start":59250,"node":100,"role":"declaration","source":0,"src_end":59906,"src_start":45077},{"artifact":1,"gen_end":78923,"gen_start":78295,"node":101,"role":"declaration","source":0,"src_end":60351,"src_start":59908},{"artifact":1,"gen_end":79579,"gen_start":78923,"node":102,"role":"declaration","source":0,"src_end":60866,"src_start":60353},{"artifact":1,"gen_end":81556,"gen_start":79579,"node":103,"role":"declaration","source":0,"src_end":62617,"src_start":60868},{"artifact":1,"gen_end":102235,"gen_start":81556,"node":104,"role":"declaration","source":0,"src_end":78672,"src_start":62619},{"artifact":1,"gen_end":102871,"gen_start":102235,"node":105,"role":"declaration","source":0,"src_end":79125,"src_start":78674},{"artifact":1,"gen_end":103535,"gen_start":102871,"node":106,"role":"declaration","source":0,"src_end":79648,"src_start":79127},{"artifact":1,"gen_end":105520,"gen_start":103535,"node":107,"role":"declaration","source":0,"src_end":81407,"src_start":79650},{"artifact":1,"gen_end":126322,"gen_start":105520,"node":108,"role":"declaration","source":0,"src_end":97540,"src_start":81409},{"artifact":1,"gen_end":126952,"gen_start":126322,"node":109,"role":"declaration","source":0,"src_end":97987,"src_start":97542},{"artifact":1,"gen_end":127610,"gen_start":126952,"node":110,"role":"declaration","source":0,"src_end":98504,"src_start":97989},{"artifact":1,"gen_end":129589,"gen_start":127610,"node":111,"role":"declaration","source":0,"src_end":100257,"src_start":98506},{"artifact":1,"gen_end":185074,"gen_start":129589,"node":112,"role":"declaration","source":0,"src_end":142701,"src_start":100259},{"artifact":1,"gen_end":185850,"gen_start":185074,"node":113,"role":"declaration","source":0,"src_end":143259,"src_start":142703},{"artifact":1,"gen_end":186216,"gen_start":185850,"node":114,"role":"declaration","source":0,"src_end":143548,"src_start":143261},{"artifact":1,"gen_end":186909,"gen_start":186216,"node":115,"role":"declaration","source":0,"src_end":144134,"src_start":143550},{"artifact":1,"gen_end":242393,"gen_start":186909,"node":116,"role":"declaration","source":0,"src_end":186577,"src_start":144136},{"artifact":1,"gen_end":243166,"gen_start":242393,"node":117,"role":"declaration","source":0,"src_end":187132,"src_start":186579},{"artifact":1,"gen_end":243529,"gen_start":243166,"node":118,"role":"declaration","source":0,"src_end":187418,"src_start":187134},{"artifact":1,"gen_end":244218,"gen_start":243529,"node":119,"role":"declaration","source":0,"src_end":188000,"src_start":187420},{"artifact":1,"gen_end":321664,"gen_start":244218,"node":120,"role":"declaration","source":0,"src_end":247140,"src_start":188002},{"artifact":1,"gen_end":322100,"gen_start":321664,"node":121,"role":"declaration","source":0,"src_end":247417,"src_start":247142},{"artifact":1,"gen_end":323403,"gen_start":322100,"node":122,"role":"declaration","source":0,"src_end":248414,"src_start":247419},{"artifact":1,"gen_end":325021,"gen_start":323403,"node":123,"role":"declaration","source":0,"src_end":249857,"src_start":248416},{"artifact":1,"gen_end":402467,"gen_start":325021,"node":124,"role":"declaration","source":0,"src_end":308997,"src_start":249859},{"artifact":1,"gen_end":402903,"gen_start":402467,"node":125,"role":"declaration","source":0,"src_end":309274,"src_start":308999},{"artifact":1,"gen_end":403860,"gen_start":402903,"node":126,"role":"declaration","source":0,"src_end":310028,"src_start":309276},{"artifact":1,"gen_end":405479,"gen_start":403860,"node":127,"role":"declaration","source":0,"src_end":311472,"src_start":310030},{"artifact":1,"gen_end":462109,"gen_start":405479,"node":128,"role":"declaration","source":0,"src_end":354793,"src_start":311474},{"artifact":1,"gen_end":462895,"gen_start":462109,"node":129,"role":"declaration","source":0,"src_end":355361,"src_start":354795},{"artifact":1,"gen_end":463367,"gen_start":462895,"node":130,"role":"declaration","source":0,"src_end":355738,"src_start":355363},{"artifact":1,"gen_end":464075,"gen_start":463367,"node":131,"role":"declaration","source":0,"src_end":356339,"src_start":355740},{"artifact":1,"gen_end":520704,"gen_start":464075,"node":132,"role":"declaration","source":0,"src_end":399659,"src_start":356341},{"artifact":1,"gen_end":521488,"gen_start":520704,"node":133,"role":"declaration","source":0,"src_end":400225,"src_start":399661},{"artifact":1,"gen_end":521957,"gen_start":521488,"node":134,"role":"declaration","source":0,"src_end":400599,"src_start":400227},{"artifact":1,"gen_end":522663,"gen_start":521957,"node":135,"role":"declaration","source":0,"src_end":401198,"src_start":400601},{"artifact":1,"gen_end":572493,"gen_start":522663,"node":136,"role":"declaration","source":0,"src_end":439258,"src_start":401200},{"artifact":1,"gen_end":572932,"gen_start":572493,"node":137,"role":"declaration","source":0,"src_end":439538,"src_start":439260},{"artifact":1,"gen_end":573884,"gen_start":572932,"node":138,"role":"declaration","source":0,"src_end":440287,"src_start":439540},{"artifact":1,"gen_end":575436,"gen_start":573884,"node":139,"role":"declaration","source":0,"src_end":441669,"src_start":440289},{"artifact":1,"gen_end":625268,"gen_start":575436,"node":140,"role":"declaration","source":0,"src_end":479731,"src_start":441671},{"artifact":1,"gen_end":625713,"gen_start":625268,"node":141,"role":"declaration","source":0,"src_end":480017,"src_start":479733},{"artifact":1,"gen_end":626672,"gen_start":625713,"node":142,"role":"declaration","source":0,"src_end":480773,"src_start":480019},{"artifact":1,"gen_end":628243,"gen_start":626672,"node":143,"role":"declaration","source":0,"src_end":482174,"src_start":480775},{"artifact":1,"gen_end":678074,"gen_start":628243,"node":144,"role":"declaration","source":0,"src_end":520235,"src_start":482176},{"artifact":1,"gen_end":678516,"gen_start":678074,"node":145,"role":"declaration","source":0,"src_end":520518,"src_start":520237},{"artifact":1,"gen_end":679649,"gen_start":678516,"node":146,"role":"declaration","source":0,"src_end":521392,"src_start":520520},{"artifact":1,"gen_end":681211,"gen_start":679649,"node":147,"role":"declaration","source":0,"src_end":522784,"src_start":521394},{"artifact":1,"gen_end":712500,"gen_start":681211,"node":148,"role":"declaration","source":0,"src_end":546611,"src_start":522786},{"artifact":1,"gen_end":713019,"gen_start":712500,"node":149,"role":"declaration","source":0,"src_end":546953,"src_start":546613},{"artifact":1,"gen_end":713376,"gen_start":713019,"node":150,"role":"declaration","source":0,"src_end":547233,"src_start":546955},{"artifact":1,"gen_end":713917,"gen_start":713376,"node":151,"role":"declaration","source":0,"src_end":547679,"src_start":547235},{"artifact":1,"gen_end":772390,"gen_start":713917,"node":152,"role":"declaration","source":0,"src_end":592392,"src_start":547681},{"artifact":1,"gen_end":773168,"gen_start":772390,"node":153,"role":"declaration","source":0,"src_end":592952,"src_start":592394},{"artifact":1,"gen_end":773536,"gen_start":773168,"node":154,"role":"declaration","source":0,"src_end":593243,"src_start":592954},{"artifact":1,"gen_end":774236,"gen_start":773536,"node":155,"role":"declaration","source":0,"src_end":593836,"src_start":593245},{"artifact":1,"gen_end":848763,"gen_start":774236,"node":156,"role":"declaration","source":0,"src_end":650834,"src_start":593838},{"artifact":1,"gen_end":849543,"gen_start":848763,"node":157,"role":"declaration","source":0,"src_end":651396,"src_start":650836},{"artifact":1,"gen_end":851160,"gen_start":849543,"node":158,"role":"declaration","source":0,"src_end":652571,"src_start":651398},{"artifact":1,"gen_end":852561,"gen_start":851160,"node":159,"role":"declaration","source":0,"src_end":653786,"src_start":652573},{"artifact":1,"gen_end":911033,"gen_start":852561,"node":160,"role":"declaration","source":0,"src_end":698498,"src_start":653788},{"artifact":1,"gen_end":911808,"gen_start":911033,"node":161,"role":"declaration","source":0,"src_end":699055,"src_start":698500},{"artifact":1,"gen_end":912173,"gen_start":911808,"node":162,"role":"declaration","source":0,"src_end":699343,"src_start":699057},{"artifact":1,"gen_end":912869,"gen_start":912173,"node":163,"role":"declaration","source":0,"src_end":699932,"src_start":699345},{"artifact":1,"gen_end":912884,"gen_start":912869,"node":82,"role":"declaration","source":0,"src_end":699968,"src_start":0}],"module":"ReasoningFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-latex-module"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/ReasoningFixtures.lex.tex","sha256":"21de0c44ebce81bb7bb1b05a6e29815cc2e6c19a58a4c85459110bf3fd1dee9c"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/ReasoningOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/ReasoningOracle.map.json index 56f1e64c4..1baf8906b 100644 --- a/compiler/expected/build/maps/LexLeanTarget/ReasoningOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/ReasoningOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ReasoningOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ReasoningOracle.tex"}],"mappings":[{"artifact":0,"gen_end":364,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":0,"gen_end":511,"gen_start":364,"node":1,"role":"declaration","source":0,"src_end":420,"src_start":124},{"artifact":0,"gen_end":688,"gen_start":511,"node":2,"role":"declaration","source":0,"src_end":796,"src_start":422},{"artifact":0,"gen_end":776,"gen_start":688,"node":3,"role":"declaration","source":0,"src_end":934,"src_start":798},{"artifact":0,"gen_end":864,"gen_start":776,"node":4,"role":"declaration","source":0,"src_end":1072,"src_start":936},{"artifact":0,"gen_end":957,"gen_start":864,"node":5,"role":"declaration","source":0,"src_end":1215,"src_start":1074},{"artifact":0,"gen_end":1045,"gen_start":957,"node":6,"role":"declaration","source":0,"src_end":1353,"src_start":1217},{"artifact":0,"gen_end":1132,"gen_start":1045,"node":7,"role":"declaration","source":0,"src_end":1490,"src_start":1355},{"artifact":0,"gen_end":1220,"gen_start":1132,"node":8,"role":"declaration","source":0,"src_end":1606,"src_start":1492},{"artifact":0,"gen_end":1309,"gen_start":1220,"node":9,"role":"declaration","source":0,"src_end":1723,"src_start":1608},{"artifact":0,"gen_end":1403,"gen_start":1309,"node":10,"role":"declaration","source":0,"src_end":1845,"src_start":1725},{"artifact":0,"gen_end":1492,"gen_start":1403,"node":11,"role":"declaration","source":0,"src_end":1962,"src_start":1847},{"artifact":0,"gen_end":1580,"gen_start":1492,"node":12,"role":"declaration","source":0,"src_end":2078,"src_start":1964},{"artifact":0,"gen_end":1788,"gen_start":1580,"node":13,"role":"declaration","source":0,"src_end":2362,"src_start":2080},{"artifact":0,"gen_end":3265,"gen_start":1788,"node":14,"role":"declaration","source":0,"src_end":4482,"src_start":2364},{"artifact":0,"gen_end":3519,"gen_start":3265,"node":15,"role":"declaration","source":0,"src_end":4820,"src_start":4484},{"artifact":0,"gen_end":3999,"gen_start":3519,"node":16,"role":"declaration","source":0,"src_end":5283,"src_start":4822},{"artifact":0,"gen_end":7147,"gen_start":3999,"node":17,"role":"declaration","source":0,"src_end":5681,"src_start":5285},{"artifact":0,"gen_end":7358,"gen_start":7147,"node":18,"role":"declaration","source":0,"src_end":5915,"src_start":5683},{"artifact":0,"gen_end":10779,"gen_start":7358,"node":19,"role":"declaration","source":0,"src_end":6685,"src_start":5917},{"artifact":0,"gen_end":14173,"gen_start":10779,"node":20,"role":"declaration","source":0,"src_end":7334,"src_start":6687},{"artifact":0,"gen_end":16050,"gen_start":14173,"node":21,"role":"declaration","source":0,"src_end":7894,"src_start":7336},{"artifact":0,"gen_end":19480,"gen_start":16050,"node":22,"role":"declaration","source":0,"src_end":8673,"src_start":7896},{"artifact":0,"gen_end":22883,"gen_start":19480,"node":23,"role":"declaration","source":0,"src_end":9331,"src_start":8675},{"artifact":0,"gen_end":24853,"gen_start":22883,"node":24,"role":"declaration","source":0,"src_end":9912,"src_start":9333},{"artifact":0,"gen_end":28280,"gen_start":24853,"node":25,"role":"declaration","source":0,"src_end":10688,"src_start":9914},{"artifact":0,"gen_end":31680,"gen_start":28280,"node":26,"role":"declaration","source":0,"src_end":11343,"src_start":10690},{"artifact":0,"gen_end":33619,"gen_start":31680,"node":27,"role":"declaration","source":0,"src_end":11917,"src_start":11345},{"artifact":0,"gen_end":37049,"gen_start":33619,"node":28,"role":"declaration","source":0,"src_end":12696,"src_start":11919},{"artifact":0,"gen_end":40452,"gen_start":37049,"node":29,"role":"declaration","source":0,"src_end":13354,"src_start":12698},{"artifact":0,"gen_end":42436,"gen_start":40452,"node":30,"role":"declaration","source":0,"src_end":13937,"src_start":13356},{"artifact":0,"gen_end":45919,"gen_start":42436,"node":31,"role":"declaration","source":0,"src_end":14785,"src_start":13939},{"artifact":0,"gen_end":49375,"gen_start":45919,"node":32,"role":"declaration","source":0,"src_end":15512,"src_start":14787},{"artifact":0,"gen_end":51270,"gen_start":49375,"node":33,"role":"declaration","source":0,"src_end":16148,"src_start":15514},{"artifact":0,"gen_end":54739,"gen_start":51270,"node":34,"role":"declaration","source":0,"src_end":16964,"src_start":16150},{"artifact":0,"gen_end":58181,"gen_start":54739,"node":35,"role":"declaration","source":0,"src_end":17659,"src_start":16966},{"artifact":0,"gen_end":60090,"gen_start":58181,"node":36,"role":"declaration","source":0,"src_end":18267,"src_start":17661},{"artifact":0,"gen_end":63546,"gen_start":60090,"node":37,"role":"declaration","source":0,"src_end":19071,"src_start":18269},{"artifact":0,"gen_end":66975,"gen_start":63546,"node":38,"role":"declaration","source":0,"src_end":19754,"src_start":19073},{"artifact":0,"gen_end":68887,"gen_start":66975,"node":39,"role":"declaration","source":0,"src_end":20348,"src_start":19756},{"artifact":0,"gen_end":72484,"gen_start":68887,"node":40,"role":"declaration","source":0,"src_end":21288,"src_start":20350},{"artifact":0,"gen_end":76054,"gen_start":72484,"node":41,"role":"declaration","source":0,"src_end":22107,"src_start":21290},{"artifact":0,"gen_end":78119,"gen_start":76054,"node":42,"role":"declaration","source":0,"src_end":22843,"src_start":22109},{"artifact":0,"gen_end":78301,"gen_start":78119,"node":43,"role":"declaration","source":0,"src_end":23052,"src_start":22845},{"artifact":0,"gen_end":78515,"gen_start":78301,"node":44,"role":"declaration","source":0,"src_end":23301,"src_start":23054},{"artifact":0,"gen_end":81722,"gen_start":78515,"node":45,"role":"declaration","source":0,"src_end":23780,"src_start":23303},{"artifact":0,"gen_end":84932,"gen_start":81722,"node":46,"role":"declaration","source":0,"src_end":24262,"src_start":23782},{"artifact":0,"gen_end":85376,"gen_start":84932,"node":47,"role":"declaration","source":0,"src_end":24546,"src_start":24264},{"artifact":0,"gen_end":85462,"gen_start":85376,"node":48,"role":"declaration","source":0,"src_end":24640,"src_start":24548},{"artifact":0,"gen_end":85551,"gen_start":85462,"node":49,"role":"declaration","source":0,"src_end":24769,"src_start":24642},{"artifact":0,"gen_end":88626,"gen_start":85551,"node":50,"role":"declaration","source":0,"src_end":25000,"src_start":24771},{"artifact":0,"gen_end":88831,"gen_start":88626,"node":51,"role":"declaration","source":0,"src_end":25204,"src_start":25002},{"artifact":0,"gen_end":91992,"gen_start":88831,"node":52,"role":"declaration","source":0,"src_end":25559,"src_start":25206},{"artifact":0,"gen_end":95151,"gen_start":91992,"node":53,"role":"declaration","source":0,"src_end":25894,"src_start":25561},{"artifact":0,"gen_end":124244,"gen_start":95151,"node":54,"role":"declaration","source":0,"src_end":26691,"src_start":25896},{"artifact":0,"gen_end":150995,"gen_start":124244,"node":55,"role":"declaration","source":0,"src_end":27383,"src_start":26693},{"artifact":0,"gen_end":151030,"gen_start":150995,"node":0,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":56,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":1,"gen_end":536,"gen_start":134,"node":57,"role":"declaration","source":0,"src_end":420,"src_start":124},{"artifact":1,"gen_end":1076,"gen_start":536,"node":58,"role":"declaration","source":0,"src_end":796,"src_start":422},{"artifact":1,"gen_end":1411,"gen_start":1076,"node":59,"role":"declaration","source":0,"src_end":934,"src_start":798},{"artifact":1,"gen_end":1746,"gen_start":1411,"node":60,"role":"declaration","source":0,"src_end":1072,"src_start":936},{"artifact":1,"gen_end":2086,"gen_start":1746,"node":61,"role":"declaration","source":0,"src_end":1215,"src_start":1074},{"artifact":1,"gen_end":2421,"gen_start":2086,"node":62,"role":"declaration","source":0,"src_end":1353,"src_start":1217},{"artifact":1,"gen_end":2755,"gen_start":2421,"node":63,"role":"declaration","source":0,"src_end":1490,"src_start":1355},{"artifact":1,"gen_end":3014,"gen_start":2755,"node":64,"role":"declaration","source":0,"src_end":1606,"src_start":1492},{"artifact":1,"gen_end":3274,"gen_start":3014,"node":65,"role":"declaration","source":0,"src_end":1723,"src_start":1608},{"artifact":1,"gen_end":3539,"gen_start":3274,"node":66,"role":"declaration","source":0,"src_end":1845,"src_start":1725},{"artifact":1,"gen_end":3799,"gen_start":3539,"node":67,"role":"declaration","source":0,"src_end":1962,"src_start":1847},{"artifact":1,"gen_end":4058,"gen_start":3799,"node":68,"role":"declaration","source":0,"src_end":2078,"src_start":1964},{"artifact":1,"gen_end":4482,"gen_start":4058,"node":69,"role":"declaration","source":0,"src_end":2362,"src_start":2080},{"artifact":1,"gen_end":6595,"gen_start":4482,"node":70,"role":"declaration","source":0,"src_end":4482,"src_start":2364},{"artifact":1,"gen_end":7125,"gen_start":6595,"node":71,"role":"declaration","source":0,"src_end":4820,"src_start":4484},{"artifact":1,"gen_end":7787,"gen_start":7125,"node":72,"role":"declaration","source":0,"src_end":5283,"src_start":4822},{"artifact":1,"gen_end":8107,"gen_start":7787,"node":73,"role":"declaration","source":0,"src_end":5681,"src_start":5285},{"artifact":1,"gen_end":8840,"gen_start":8107,"node":74,"role":"declaration","source":0,"src_end":5915,"src_start":5683},{"artifact":1,"gen_end":9389,"gen_start":8840,"node":75,"role":"declaration","source":0,"src_end":6685,"src_start":5917},{"artifact":1,"gen_end":9953,"gen_start":9389,"node":76,"role":"declaration","source":0,"src_end":7334,"src_start":6687},{"artifact":1,"gen_end":12552,"gen_start":9953,"node":77,"role":"declaration","source":0,"src_end":7894,"src_start":7336},{"artifact":1,"gen_end":13110,"gen_start":12552,"node":78,"role":"declaration","source":0,"src_end":8673,"src_start":7896},{"artifact":1,"gen_end":13683,"gen_start":13110,"node":79,"role":"declaration","source":0,"src_end":9331,"src_start":8675},{"artifact":1,"gen_end":16390,"gen_start":13683,"node":80,"role":"declaration","source":0,"src_end":9912,"src_start":9333},{"artifact":1,"gen_end":16945,"gen_start":16390,"node":81,"role":"declaration","source":0,"src_end":10688,"src_start":9914},{"artifact":1,"gen_end":17515,"gen_start":16945,"node":82,"role":"declaration","source":0,"src_end":11343,"src_start":10690},{"artifact":1,"gen_end":20186,"gen_start":17515,"node":83,"role":"declaration","source":0,"src_end":11917,"src_start":11345},{"artifact":1,"gen_end":20744,"gen_start":20186,"node":84,"role":"declaration","source":0,"src_end":12696,"src_start":11919},{"artifact":1,"gen_end":21317,"gen_start":20744,"node":85,"role":"declaration","source":0,"src_end":13354,"src_start":12698},{"artifact":1,"gen_end":24036,"gen_start":21317,"node":86,"role":"declaration","source":0,"src_end":13937,"src_start":13356},{"artifact":1,"gen_end":24647,"gen_start":24036,"node":87,"role":"declaration","source":0,"src_end":14785,"src_start":13939},{"artifact":1,"gen_end":25273,"gen_start":24647,"node":88,"role":"declaration","source":0,"src_end":15512,"src_start":14787},{"artifact":1,"gen_end":28108,"gen_start":25273,"node":89,"role":"declaration","source":0,"src_end":16148,"src_start":15514},{"artifact":1,"gen_end":28707,"gen_start":28108,"node":90,"role":"declaration","source":0,"src_end":16964,"src_start":16150},{"artifact":1,"gen_end":29321,"gen_start":28707,"node":91,"role":"declaration","source":0,"src_end":17659,"src_start":16966},{"artifact":1,"gen_end":32132,"gen_start":29321,"node":92,"role":"declaration","source":0,"src_end":18267,"src_start":17661},{"artifact":1,"gen_end":32718,"gen_start":32132,"node":93,"role":"declaration","source":0,"src_end":19071,"src_start":18269},{"artifact":1,"gen_end":33319,"gen_start":32718,"node":94,"role":"declaration","source":0,"src_end":19754,"src_start":19073},{"artifact":1,"gen_end":36066,"gen_start":33319,"node":95,"role":"declaration","source":0,"src_end":20348,"src_start":19756},{"artifact":1,"gen_end":36797,"gen_start":36066,"node":96,"role":"declaration","source":0,"src_end":21288,"src_start":20350},{"artifact":1,"gen_end":37543,"gen_start":36797,"node":97,"role":"declaration","source":0,"src_end":22107,"src_start":21290},{"artifact":1,"gen_end":40906,"gen_start":37543,"node":98,"role":"declaration","source":0,"src_end":22843,"src_start":22109},{"artifact":1,"gen_end":41319,"gen_start":40906,"node":99,"role":"declaration","source":0,"src_end":23052,"src_start":22845},{"artifact":1,"gen_end":41788,"gen_start":41319,"node":100,"role":"declaration","source":0,"src_end":23301,"src_start":23054},{"artifact":1,"gen_end":42109,"gen_start":41788,"node":101,"role":"declaration","source":0,"src_end":23780,"src_start":23303},{"artifact":1,"gen_end":42433,"gen_start":42109,"node":102,"role":"declaration","source":0,"src_end":24262,"src_start":23782},{"artifact":1,"gen_end":43603,"gen_start":42433,"node":103,"role":"declaration","source":0,"src_end":24546,"src_start":24264},{"artifact":1,"gen_end":43859,"gen_start":43603,"node":104,"role":"declaration","source":0,"src_end":24640,"src_start":24548},{"artifact":1,"gen_end":44194,"gen_start":43859,"node":105,"role":"declaration","source":0,"src_end":24769,"src_start":24642},{"artifact":1,"gen_end":44476,"gen_start":44194,"node":106,"role":"declaration","source":0,"src_end":25000,"src_start":24771},{"artifact":1,"gen_end":45162,"gen_start":44476,"node":107,"role":"declaration","source":0,"src_end":25204,"src_start":25002},{"artifact":1,"gen_end":45578,"gen_start":45162,"node":108,"role":"declaration","source":0,"src_end":25559,"src_start":25206},{"artifact":1,"gen_end":45977,"gen_start":45578,"node":109,"role":"declaration","source":0,"src_end":25894,"src_start":25561},{"artifact":1,"gen_end":62729,"gen_start":45977,"node":110,"role":"declaration","source":0,"src_end":26691,"src_start":25896},{"artifact":1,"gen_end":78144,"gen_start":62729,"node":111,"role":"declaration","source":0,"src_end":27383,"src_start":26693},{"artifact":1,"gen_end":78159,"gen_start":78144,"node":56,"role":"declaration","source":0,"src_end":27419,"src_start":0}],"module":"ReasoningOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-latex-module"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/ReasoningOracle.lex.tex","sha256":"7d5e680324c4fbffa4b8906aefe2e502d20994ff8cdaf223eb385e814bec77bb"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ReasoningOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ReasoningOracle.tex"}],"mappings":[{"artifact":0,"gen_end":364,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":0,"gen_end":511,"gen_start":364,"node":1,"role":"declaration","source":0,"src_end":420,"src_start":124},{"artifact":0,"gen_end":688,"gen_start":511,"node":2,"role":"declaration","source":0,"src_end":796,"src_start":422},{"artifact":0,"gen_end":776,"gen_start":688,"node":3,"role":"declaration","source":0,"src_end":934,"src_start":798},{"artifact":0,"gen_end":864,"gen_start":776,"node":4,"role":"declaration","source":0,"src_end":1072,"src_start":936},{"artifact":0,"gen_end":957,"gen_start":864,"node":5,"role":"declaration","source":0,"src_end":1215,"src_start":1074},{"artifact":0,"gen_end":1045,"gen_start":957,"node":6,"role":"declaration","source":0,"src_end":1353,"src_start":1217},{"artifact":0,"gen_end":1132,"gen_start":1045,"node":7,"role":"declaration","source":0,"src_end":1490,"src_start":1355},{"artifact":0,"gen_end":1220,"gen_start":1132,"node":8,"role":"declaration","source":0,"src_end":1606,"src_start":1492},{"artifact":0,"gen_end":1309,"gen_start":1220,"node":9,"role":"declaration","source":0,"src_end":1723,"src_start":1608},{"artifact":0,"gen_end":1403,"gen_start":1309,"node":10,"role":"declaration","source":0,"src_end":1845,"src_start":1725},{"artifact":0,"gen_end":1492,"gen_start":1403,"node":11,"role":"declaration","source":0,"src_end":1962,"src_start":1847},{"artifact":0,"gen_end":1580,"gen_start":1492,"node":12,"role":"declaration","source":0,"src_end":2078,"src_start":1964},{"artifact":0,"gen_end":1788,"gen_start":1580,"node":13,"role":"declaration","source":0,"src_end":2362,"src_start":2080},{"artifact":0,"gen_end":3265,"gen_start":1788,"node":14,"role":"declaration","source":0,"src_end":4482,"src_start":2364},{"artifact":0,"gen_end":3519,"gen_start":3265,"node":15,"role":"declaration","source":0,"src_end":4820,"src_start":4484},{"artifact":0,"gen_end":3999,"gen_start":3519,"node":16,"role":"declaration","source":0,"src_end":5283,"src_start":4822},{"artifact":0,"gen_end":7147,"gen_start":3999,"node":17,"role":"declaration","source":0,"src_end":5681,"src_start":5285},{"artifact":0,"gen_end":7358,"gen_start":7147,"node":18,"role":"declaration","source":0,"src_end":5915,"src_start":5683},{"artifact":0,"gen_end":10779,"gen_start":7358,"node":19,"role":"declaration","source":0,"src_end":6685,"src_start":5917},{"artifact":0,"gen_end":14173,"gen_start":10779,"node":20,"role":"declaration","source":0,"src_end":7334,"src_start":6687},{"artifact":0,"gen_end":16050,"gen_start":14173,"node":21,"role":"declaration","source":0,"src_end":7894,"src_start":7336},{"artifact":0,"gen_end":19480,"gen_start":16050,"node":22,"role":"declaration","source":0,"src_end":8673,"src_start":7896},{"artifact":0,"gen_end":22883,"gen_start":19480,"node":23,"role":"declaration","source":0,"src_end":9331,"src_start":8675},{"artifact":0,"gen_end":24853,"gen_start":22883,"node":24,"role":"declaration","source":0,"src_end":9912,"src_start":9333},{"artifact":0,"gen_end":28280,"gen_start":24853,"node":25,"role":"declaration","source":0,"src_end":10688,"src_start":9914},{"artifact":0,"gen_end":31680,"gen_start":28280,"node":26,"role":"declaration","source":0,"src_end":11343,"src_start":10690},{"artifact":0,"gen_end":33619,"gen_start":31680,"node":27,"role":"declaration","source":0,"src_end":11917,"src_start":11345},{"artifact":0,"gen_end":37049,"gen_start":33619,"node":28,"role":"declaration","source":0,"src_end":12696,"src_start":11919},{"artifact":0,"gen_end":40452,"gen_start":37049,"node":29,"role":"declaration","source":0,"src_end":13354,"src_start":12698},{"artifact":0,"gen_end":42436,"gen_start":40452,"node":30,"role":"declaration","source":0,"src_end":13937,"src_start":13356},{"artifact":0,"gen_end":45919,"gen_start":42436,"node":31,"role":"declaration","source":0,"src_end":14785,"src_start":13939},{"artifact":0,"gen_end":49375,"gen_start":45919,"node":32,"role":"declaration","source":0,"src_end":15512,"src_start":14787},{"artifact":0,"gen_end":51270,"gen_start":49375,"node":33,"role":"declaration","source":0,"src_end":16148,"src_start":15514},{"artifact":0,"gen_end":54739,"gen_start":51270,"node":34,"role":"declaration","source":0,"src_end":16964,"src_start":16150},{"artifact":0,"gen_end":58181,"gen_start":54739,"node":35,"role":"declaration","source":0,"src_end":17659,"src_start":16966},{"artifact":0,"gen_end":60090,"gen_start":58181,"node":36,"role":"declaration","source":0,"src_end":18267,"src_start":17661},{"artifact":0,"gen_end":63546,"gen_start":60090,"node":37,"role":"declaration","source":0,"src_end":19071,"src_start":18269},{"artifact":0,"gen_end":66975,"gen_start":63546,"node":38,"role":"declaration","source":0,"src_end":19754,"src_start":19073},{"artifact":0,"gen_end":68887,"gen_start":66975,"node":39,"role":"declaration","source":0,"src_end":20348,"src_start":19756},{"artifact":0,"gen_end":72484,"gen_start":68887,"node":40,"role":"declaration","source":0,"src_end":21288,"src_start":20350},{"artifact":0,"gen_end":76054,"gen_start":72484,"node":41,"role":"declaration","source":0,"src_end":22107,"src_start":21290},{"artifact":0,"gen_end":78119,"gen_start":76054,"node":42,"role":"declaration","source":0,"src_end":22843,"src_start":22109},{"artifact":0,"gen_end":78301,"gen_start":78119,"node":43,"role":"declaration","source":0,"src_end":23052,"src_start":22845},{"artifact":0,"gen_end":78515,"gen_start":78301,"node":44,"role":"declaration","source":0,"src_end":23301,"src_start":23054},{"artifact":0,"gen_end":81722,"gen_start":78515,"node":45,"role":"declaration","source":0,"src_end":23780,"src_start":23303},{"artifact":0,"gen_end":84932,"gen_start":81722,"node":46,"role":"declaration","source":0,"src_end":24262,"src_start":23782},{"artifact":0,"gen_end":85376,"gen_start":84932,"node":47,"role":"declaration","source":0,"src_end":24546,"src_start":24264},{"artifact":0,"gen_end":85462,"gen_start":85376,"node":48,"role":"declaration","source":0,"src_end":24640,"src_start":24548},{"artifact":0,"gen_end":85551,"gen_start":85462,"node":49,"role":"declaration","source":0,"src_end":24769,"src_start":24642},{"artifact":0,"gen_end":88626,"gen_start":85551,"node":50,"role":"declaration","source":0,"src_end":25000,"src_start":24771},{"artifact":0,"gen_end":88831,"gen_start":88626,"node":51,"role":"declaration","source":0,"src_end":25204,"src_start":25002},{"artifact":0,"gen_end":91992,"gen_start":88831,"node":52,"role":"declaration","source":0,"src_end":25559,"src_start":25206},{"artifact":0,"gen_end":95151,"gen_start":91992,"node":53,"role":"declaration","source":0,"src_end":25894,"src_start":25561},{"artifact":0,"gen_end":124244,"gen_start":95151,"node":54,"role":"declaration","source":0,"src_end":26691,"src_start":25896},{"artifact":0,"gen_end":150995,"gen_start":124244,"node":55,"role":"declaration","source":0,"src_end":27383,"src_start":26693},{"artifact":0,"gen_end":151030,"gen_start":150995,"node":0,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":56,"role":"declaration","source":0,"src_end":27419,"src_start":0},{"artifact":1,"gen_end":536,"gen_start":134,"node":57,"role":"declaration","source":0,"src_end":420,"src_start":124},{"artifact":1,"gen_end":1076,"gen_start":536,"node":58,"role":"declaration","source":0,"src_end":796,"src_start":422},{"artifact":1,"gen_end":1411,"gen_start":1076,"node":59,"role":"declaration","source":0,"src_end":934,"src_start":798},{"artifact":1,"gen_end":1746,"gen_start":1411,"node":60,"role":"declaration","source":0,"src_end":1072,"src_start":936},{"artifact":1,"gen_end":2086,"gen_start":1746,"node":61,"role":"declaration","source":0,"src_end":1215,"src_start":1074},{"artifact":1,"gen_end":2421,"gen_start":2086,"node":62,"role":"declaration","source":0,"src_end":1353,"src_start":1217},{"artifact":1,"gen_end":2755,"gen_start":2421,"node":63,"role":"declaration","source":0,"src_end":1490,"src_start":1355},{"artifact":1,"gen_end":3014,"gen_start":2755,"node":64,"role":"declaration","source":0,"src_end":1606,"src_start":1492},{"artifact":1,"gen_end":3274,"gen_start":3014,"node":65,"role":"declaration","source":0,"src_end":1723,"src_start":1608},{"artifact":1,"gen_end":3539,"gen_start":3274,"node":66,"role":"declaration","source":0,"src_end":1845,"src_start":1725},{"artifact":1,"gen_end":3799,"gen_start":3539,"node":67,"role":"declaration","source":0,"src_end":1962,"src_start":1847},{"artifact":1,"gen_end":4058,"gen_start":3799,"node":68,"role":"declaration","source":0,"src_end":2078,"src_start":1964},{"artifact":1,"gen_end":4482,"gen_start":4058,"node":69,"role":"declaration","source":0,"src_end":2362,"src_start":2080},{"artifact":1,"gen_end":6595,"gen_start":4482,"node":70,"role":"declaration","source":0,"src_end":4482,"src_start":2364},{"artifact":1,"gen_end":7125,"gen_start":6595,"node":71,"role":"declaration","source":0,"src_end":4820,"src_start":4484},{"artifact":1,"gen_end":7787,"gen_start":7125,"node":72,"role":"declaration","source":0,"src_end":5283,"src_start":4822},{"artifact":1,"gen_end":8107,"gen_start":7787,"node":73,"role":"declaration","source":0,"src_end":5681,"src_start":5285},{"artifact":1,"gen_end":8840,"gen_start":8107,"node":74,"role":"declaration","source":0,"src_end":5915,"src_start":5683},{"artifact":1,"gen_end":9389,"gen_start":8840,"node":75,"role":"declaration","source":0,"src_end":6685,"src_start":5917},{"artifact":1,"gen_end":9953,"gen_start":9389,"node":76,"role":"declaration","source":0,"src_end":7334,"src_start":6687},{"artifact":1,"gen_end":12552,"gen_start":9953,"node":77,"role":"declaration","source":0,"src_end":7894,"src_start":7336},{"artifact":1,"gen_end":13110,"gen_start":12552,"node":78,"role":"declaration","source":0,"src_end":8673,"src_start":7896},{"artifact":1,"gen_end":13683,"gen_start":13110,"node":79,"role":"declaration","source":0,"src_end":9331,"src_start":8675},{"artifact":1,"gen_end":16390,"gen_start":13683,"node":80,"role":"declaration","source":0,"src_end":9912,"src_start":9333},{"artifact":1,"gen_end":16945,"gen_start":16390,"node":81,"role":"declaration","source":0,"src_end":10688,"src_start":9914},{"artifact":1,"gen_end":17515,"gen_start":16945,"node":82,"role":"declaration","source":0,"src_end":11343,"src_start":10690},{"artifact":1,"gen_end":20186,"gen_start":17515,"node":83,"role":"declaration","source":0,"src_end":11917,"src_start":11345},{"artifact":1,"gen_end":20744,"gen_start":20186,"node":84,"role":"declaration","source":0,"src_end":12696,"src_start":11919},{"artifact":1,"gen_end":21317,"gen_start":20744,"node":85,"role":"declaration","source":0,"src_end":13354,"src_start":12698},{"artifact":1,"gen_end":24036,"gen_start":21317,"node":86,"role":"declaration","source":0,"src_end":13937,"src_start":13356},{"artifact":1,"gen_end":24647,"gen_start":24036,"node":87,"role":"declaration","source":0,"src_end":14785,"src_start":13939},{"artifact":1,"gen_end":25273,"gen_start":24647,"node":88,"role":"declaration","source":0,"src_end":15512,"src_start":14787},{"artifact":1,"gen_end":28108,"gen_start":25273,"node":89,"role":"declaration","source":0,"src_end":16148,"src_start":15514},{"artifact":1,"gen_end":28707,"gen_start":28108,"node":90,"role":"declaration","source":0,"src_end":16964,"src_start":16150},{"artifact":1,"gen_end":29321,"gen_start":28707,"node":91,"role":"declaration","source":0,"src_end":17659,"src_start":16966},{"artifact":1,"gen_end":32132,"gen_start":29321,"node":92,"role":"declaration","source":0,"src_end":18267,"src_start":17661},{"artifact":1,"gen_end":32718,"gen_start":32132,"node":93,"role":"declaration","source":0,"src_end":19071,"src_start":18269},{"artifact":1,"gen_end":33319,"gen_start":32718,"node":94,"role":"declaration","source":0,"src_end":19754,"src_start":19073},{"artifact":1,"gen_end":36066,"gen_start":33319,"node":95,"role":"declaration","source":0,"src_end":20348,"src_start":19756},{"artifact":1,"gen_end":36797,"gen_start":36066,"node":96,"role":"declaration","source":0,"src_end":21288,"src_start":20350},{"artifact":1,"gen_end":37543,"gen_start":36797,"node":97,"role":"declaration","source":0,"src_end":22107,"src_start":21290},{"artifact":1,"gen_end":40906,"gen_start":37543,"node":98,"role":"declaration","source":0,"src_end":22843,"src_start":22109},{"artifact":1,"gen_end":41319,"gen_start":40906,"node":99,"role":"declaration","source":0,"src_end":23052,"src_start":22845},{"artifact":1,"gen_end":41788,"gen_start":41319,"node":100,"role":"declaration","source":0,"src_end":23301,"src_start":23054},{"artifact":1,"gen_end":42109,"gen_start":41788,"node":101,"role":"declaration","source":0,"src_end":23780,"src_start":23303},{"artifact":1,"gen_end":42433,"gen_start":42109,"node":102,"role":"declaration","source":0,"src_end":24262,"src_start":23782},{"artifact":1,"gen_end":43603,"gen_start":42433,"node":103,"role":"declaration","source":0,"src_end":24546,"src_start":24264},{"artifact":1,"gen_end":43859,"gen_start":43603,"node":104,"role":"declaration","source":0,"src_end":24640,"src_start":24548},{"artifact":1,"gen_end":44194,"gen_start":43859,"node":105,"role":"declaration","source":0,"src_end":24769,"src_start":24642},{"artifact":1,"gen_end":44476,"gen_start":44194,"node":106,"role":"declaration","source":0,"src_end":25000,"src_start":24771},{"artifact":1,"gen_end":45162,"gen_start":44476,"node":107,"role":"declaration","source":0,"src_end":25204,"src_start":25002},{"artifact":1,"gen_end":45578,"gen_start":45162,"node":108,"role":"declaration","source":0,"src_end":25559,"src_start":25206},{"artifact":1,"gen_end":45977,"gen_start":45578,"node":109,"role":"declaration","source":0,"src_end":25894,"src_start":25561},{"artifact":1,"gen_end":62729,"gen_start":45977,"node":110,"role":"declaration","source":0,"src_end":26691,"src_start":25896},{"artifact":1,"gen_end":78144,"gen_start":62729,"node":111,"role":"declaration","source":0,"src_end":27383,"src_start":26693},{"artifact":1,"gen_end":78159,"gen_start":78144,"node":56,"role":"declaration","source":0,"src_end":27419,"src_start":0}],"module":"ReasoningOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-latex-module"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/ReasoningOracle.lex.tex","sha256":"7d5e680324c4fbffa4b8906aefe2e502d20994ff8cdaf223eb385e814bec77bb"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/RustSemantics.map.json b/compiler/expected/build/maps/LexLeanTarget/RustSemantics.map.json index 83dbe7258..badaaa25a 100644 --- a/compiler/expected/build/maps/LexLeanTarget/RustSemantics.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/RustSemantics.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/RustSemantics.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/RustSemantics.tex"}],"mappings":[{"artifact":0,"gen_end":372,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":0,"gen_end":498,"gen_start":372,"node":1,"role":"declaration","source":0,"src_end":477,"src_start":207},{"artifact":0,"gen_end":633,"gen_start":498,"node":2,"role":"declaration","source":0,"src_end":758,"src_start":479},{"artifact":0,"gen_end":1179,"gen_start":633,"node":3,"role":"declaration","source":0,"src_end":1236,"src_start":760},{"artifact":0,"gen_end":1838,"gen_start":1179,"node":4,"role":"declaration","source":0,"src_end":1827,"src_start":1238},{"artifact":0,"gen_end":2213,"gen_start":1838,"node":5,"role":"declaration","source":0,"src_end":2289,"src_start":1829},{"artifact":0,"gen_end":4974,"gen_start":2213,"node":6,"role":"declaration","source":0,"src_end":5469,"src_start":2291},{"artifact":0,"gen_end":6897,"gen_start":4974,"node":7,"role":"declaration","source":0,"src_end":7876,"src_start":5471},{"artifact":0,"gen_end":19066,"gen_start":6897,"node":8,"role":"declaration","source":0,"src_end":30493,"src_start":7878},{"artifact":0,"gen_end":19855,"gen_start":19066,"node":9,"role":"declaration","source":0,"src_end":31684,"src_start":30495},{"artifact":0,"gen_end":23042,"gen_start":19855,"node":10,"role":"declaration","source":0,"src_end":36293,"src_start":31686},{"artifact":0,"gen_end":27513,"gen_start":23042,"node":11,"role":"declaration","source":0,"src_end":40127,"src_start":36295},{"artifact":0,"gen_end":30132,"gen_start":27513,"node":12,"role":"declaration","source":0,"src_end":42351,"src_start":40129},{"artifact":0,"gen_end":32738,"gen_start":30132,"node":13,"role":"declaration","source":0,"src_end":44562,"src_start":42353},{"artifact":0,"gen_end":35665,"gen_start":32738,"node":14,"role":"declaration","source":0,"src_end":47097,"src_start":44564},{"artifact":0,"gen_end":45673,"gen_start":35665,"node":15,"role":"declaration","source":0,"src_end":57456,"src_start":47099},{"artifact":0,"gen_end":45940,"gen_start":45673,"node":16,"role":"declaration","source":0,"src_end":57756,"src_start":57458},{"artifact":0,"gen_end":49024,"gen_start":45940,"node":17,"role":"declaration","source":0,"src_end":61922,"src_start":57758},{"artifact":0,"gen_end":51648,"gen_start":49024,"node":18,"role":"declaration","source":0,"src_end":64151,"src_start":61924},{"artifact":0,"gen_end":52919,"gen_start":51648,"node":19,"role":"declaration","source":0,"src_end":65449,"src_start":64153},{"artifact":0,"gen_end":54191,"gen_start":52919,"node":20,"role":"declaration","source":0,"src_end":66748,"src_start":65451},{"artifact":0,"gen_end":55464,"gen_start":54191,"node":21,"role":"declaration","source":0,"src_end":68048,"src_start":66750},{"artifact":0,"gen_end":58178,"gen_start":55464,"node":22,"role":"declaration","source":0,"src_end":70536,"src_start":68050},{"artifact":0,"gen_end":58637,"gen_start":58178,"node":23,"role":"declaration","source":0,"src_end":71177,"src_start":70538},{"artifact":0,"gen_end":60274,"gen_start":58637,"node":24,"role":"declaration","source":0,"src_end":72838,"src_start":71179},{"artifact":0,"gen_end":61944,"gen_start":60274,"node":25,"role":"declaration","source":0,"src_end":74784,"src_start":72840},{"artifact":0,"gen_end":62080,"gen_start":61944,"node":26,"role":"declaration","source":0,"src_end":74950,"src_start":74786},{"artifact":0,"gen_end":62443,"gen_start":62080,"node":27,"role":"declaration","source":0,"src_end":75383,"src_start":74952},{"artifact":0,"gen_end":63153,"gen_start":62443,"node":28,"role":"declaration","source":0,"src_end":76268,"src_start":75385},{"artifact":0,"gen_end":63575,"gen_start":63153,"node":29,"role":"declaration","source":0,"src_end":76725,"src_start":76270},{"artifact":0,"gen_end":64255,"gen_start":63575,"node":30,"role":"declaration","source":0,"src_end":77526,"src_start":76727},{"artifact":0,"gen_end":65239,"gen_start":64255,"node":31,"role":"declaration","source":0,"src_end":78480,"src_start":77528},{"artifact":0,"gen_end":65665,"gen_start":65239,"node":32,"role":"declaration","source":0,"src_end":78975,"src_start":78482},{"artifact":0,"gen_end":65922,"gen_start":65665,"node":33,"role":"declaration","source":0,"src_end":79432,"src_start":78977},{"artifact":0,"gen_end":82859,"gen_start":65922,"node":34,"role":"declaration","source":0,"src_end":98969,"src_start":79434},{"artifact":0,"gen_end":83963,"gen_start":82859,"node":35,"role":"declaration","source":0,"src_end":100183,"src_start":98971},{"artifact":0,"gen_end":85072,"gen_start":83963,"node":36,"role":"declaration","source":0,"src_end":101374,"src_start":100185},{"artifact":0,"gen_end":85915,"gen_start":85072,"node":37,"role":"declaration","source":0,"src_end":102359,"src_start":101376},{"artifact":0,"gen_end":86705,"gen_start":85915,"node":38,"role":"declaration","source":0,"src_end":103175,"src_start":102361},{"artifact":0,"gen_end":86958,"gen_start":86705,"node":39,"role":"declaration","source":0,"src_end":103487,"src_start":103177},{"artifact":0,"gen_end":86991,"gen_start":86958,"node":0,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":40,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":1,"gen_end":517,"gen_start":134,"node":41,"role":"declaration","source":0,"src_end":477,"src_start":207},{"artifact":1,"gen_end":909,"gen_start":517,"node":42,"role":"declaration","source":0,"src_end":758,"src_start":479},{"artifact":1,"gen_end":1637,"gen_start":909,"node":43,"role":"declaration","source":0,"src_end":1236,"src_start":760},{"artifact":1,"gen_end":2483,"gen_start":1637,"node":44,"role":"declaration","source":0,"src_end":1827,"src_start":1238},{"artifact":1,"gen_end":3045,"gen_start":2483,"node":45,"role":"declaration","source":0,"src_end":2289,"src_start":1829},{"artifact":1,"gen_end":6011,"gen_start":3045,"node":46,"role":"declaration","source":0,"src_end":5469,"src_start":2291},{"artifact":1,"gen_end":8131,"gen_start":6011,"node":47,"role":"declaration","source":0,"src_end":7876,"src_start":5471},{"artifact":1,"gen_end":20493,"gen_start":8131,"node":48,"role":"declaration","source":0,"src_end":30493,"src_start":7878},{"artifact":1,"gen_end":21470,"gen_start":20493,"node":49,"role":"declaration","source":0,"src_end":31684,"src_start":30495},{"artifact":1,"gen_end":24882,"gen_start":21470,"node":50,"role":"declaration","source":0,"src_end":36293,"src_start":31686},{"artifact":1,"gen_end":29547,"gen_start":24882,"node":51,"role":"declaration","source":0,"src_end":40127,"src_start":36295},{"artifact":1,"gen_end":32362,"gen_start":29547,"node":52,"role":"declaration","source":0,"src_end":42351,"src_start":40129},{"artifact":1,"gen_end":35164,"gen_start":32362,"node":53,"role":"declaration","source":0,"src_end":44562,"src_start":42353},{"artifact":1,"gen_end":38287,"gen_start":35164,"node":54,"role":"declaration","source":0,"src_end":47097,"src_start":44564},{"artifact":1,"gen_end":48669,"gen_start":38287,"node":55,"role":"declaration","source":0,"src_end":57456,"src_start":47099},{"artifact":1,"gen_end":49118,"gen_start":48669,"node":56,"role":"declaration","source":0,"src_end":57756,"src_start":57458},{"artifact":1,"gen_end":52386,"gen_start":49118,"node":57,"role":"declaration","source":0,"src_end":61922,"src_start":57758},{"artifact":1,"gen_end":55206,"gen_start":52386,"node":58,"role":"declaration","source":0,"src_end":64151,"src_start":61924},{"artifact":1,"gen_end":56683,"gen_start":55206,"node":59,"role":"declaration","source":0,"src_end":65449,"src_start":64153},{"artifact":1,"gen_end":58161,"gen_start":56683,"node":60,"role":"declaration","source":0,"src_end":66748,"src_start":65451},{"artifact":1,"gen_end":59640,"gen_start":58161,"node":61,"role":"declaration","source":0,"src_end":68048,"src_start":66750},{"artifact":1,"gen_end":62550,"gen_start":59640,"node":62,"role":"declaration","source":0,"src_end":70536,"src_start":68050},{"artifact":1,"gen_end":63193,"gen_start":62550,"node":63,"role":"declaration","source":0,"src_end":71177,"src_start":70538},{"artifact":1,"gen_end":65057,"gen_start":63193,"node":64,"role":"declaration","source":0,"src_end":72838,"src_start":71179},{"artifact":1,"gen_end":66932,"gen_start":65057,"node":65,"role":"declaration","source":0,"src_end":74784,"src_start":72840},{"artifact":1,"gen_end":67250,"gen_start":66932,"node":66,"role":"declaration","source":0,"src_end":74950,"src_start":74786},{"artifact":1,"gen_end":67795,"gen_start":67250,"node":67,"role":"declaration","source":0,"src_end":75383,"src_start":74952},{"artifact":1,"gen_end":68689,"gen_start":67795,"node":68,"role":"declaration","source":0,"src_end":76268,"src_start":75385},{"artifact":1,"gen_end":69267,"gen_start":68689,"node":69,"role":"declaration","source":0,"src_end":76725,"src_start":76270},{"artifact":1,"gen_end":70111,"gen_start":69267,"node":70,"role":"declaration","source":0,"src_end":77526,"src_start":76727},{"artifact":1,"gen_end":71289,"gen_start":70111,"node":71,"role":"declaration","source":0,"src_end":78480,"src_start":77528},{"artifact":1,"gen_end":71897,"gen_start":71289,"node":72,"role":"declaration","source":0,"src_end":78975,"src_start":78482},{"artifact":1,"gen_end":72356,"gen_start":71897,"node":73,"role":"declaration","source":0,"src_end":79432,"src_start":78977},{"artifact":1,"gen_end":89648,"gen_start":72356,"node":74,"role":"declaration","source":0,"src_end":98969,"src_start":79434},{"artifact":1,"gen_end":90950,"gen_start":89648,"node":75,"role":"declaration","source":0,"src_end":100183,"src_start":98971},{"artifact":1,"gen_end":92270,"gen_start":90950,"node":76,"role":"declaration","source":0,"src_end":101374,"src_start":100185},{"artifact":1,"gen_end":93297,"gen_start":92270,"node":77,"role":"declaration","source":0,"src_end":102359,"src_start":101376},{"artifact":1,"gen_end":94295,"gen_start":93297,"node":78,"role":"declaration","source":0,"src_end":103175,"src_start":102361},{"artifact":1,"gen_end":94771,"gen_start":94295,"node":79,"role":"declaration","source":0,"src_end":103487,"src_start":103177},{"artifact":1,"gen_end":94786,"gen_start":94771,"node":40,"role":"declaration","source":0,"src_end":103523,"src_start":0}],"module":"RustSemantics","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-latex-module"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/RustSemantics.lex.tex","sha256":"183644ea3d81403440add2ca225c82d462dde21a7c5a7928d2c313a12e9242b3"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/RustSemantics.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/RustSemantics.tex"}],"mappings":[{"artifact":0,"gen_end":372,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":0,"gen_end":498,"gen_start":372,"node":1,"role":"declaration","source":0,"src_end":477,"src_start":207},{"artifact":0,"gen_end":633,"gen_start":498,"node":2,"role":"declaration","source":0,"src_end":758,"src_start":479},{"artifact":0,"gen_end":1179,"gen_start":633,"node":3,"role":"declaration","source":0,"src_end":1236,"src_start":760},{"artifact":0,"gen_end":1838,"gen_start":1179,"node":4,"role":"declaration","source":0,"src_end":1827,"src_start":1238},{"artifact":0,"gen_end":2213,"gen_start":1838,"node":5,"role":"declaration","source":0,"src_end":2289,"src_start":1829},{"artifact":0,"gen_end":4974,"gen_start":2213,"node":6,"role":"declaration","source":0,"src_end":5469,"src_start":2291},{"artifact":0,"gen_end":6897,"gen_start":4974,"node":7,"role":"declaration","source":0,"src_end":7876,"src_start":5471},{"artifact":0,"gen_end":19066,"gen_start":6897,"node":8,"role":"declaration","source":0,"src_end":30493,"src_start":7878},{"artifact":0,"gen_end":19855,"gen_start":19066,"node":9,"role":"declaration","source":0,"src_end":31684,"src_start":30495},{"artifact":0,"gen_end":23042,"gen_start":19855,"node":10,"role":"declaration","source":0,"src_end":36293,"src_start":31686},{"artifact":0,"gen_end":27513,"gen_start":23042,"node":11,"role":"declaration","source":0,"src_end":40127,"src_start":36295},{"artifact":0,"gen_end":30132,"gen_start":27513,"node":12,"role":"declaration","source":0,"src_end":42351,"src_start":40129},{"artifact":0,"gen_end":32738,"gen_start":30132,"node":13,"role":"declaration","source":0,"src_end":44562,"src_start":42353},{"artifact":0,"gen_end":35665,"gen_start":32738,"node":14,"role":"declaration","source":0,"src_end":47097,"src_start":44564},{"artifact":0,"gen_end":45673,"gen_start":35665,"node":15,"role":"declaration","source":0,"src_end":57456,"src_start":47099},{"artifact":0,"gen_end":45940,"gen_start":45673,"node":16,"role":"declaration","source":0,"src_end":57756,"src_start":57458},{"artifact":0,"gen_end":49024,"gen_start":45940,"node":17,"role":"declaration","source":0,"src_end":61922,"src_start":57758},{"artifact":0,"gen_end":51648,"gen_start":49024,"node":18,"role":"declaration","source":0,"src_end":64151,"src_start":61924},{"artifact":0,"gen_end":52919,"gen_start":51648,"node":19,"role":"declaration","source":0,"src_end":65449,"src_start":64153},{"artifact":0,"gen_end":54191,"gen_start":52919,"node":20,"role":"declaration","source":0,"src_end":66748,"src_start":65451},{"artifact":0,"gen_end":55464,"gen_start":54191,"node":21,"role":"declaration","source":0,"src_end":68048,"src_start":66750},{"artifact":0,"gen_end":58178,"gen_start":55464,"node":22,"role":"declaration","source":0,"src_end":70536,"src_start":68050},{"artifact":0,"gen_end":58637,"gen_start":58178,"node":23,"role":"declaration","source":0,"src_end":71177,"src_start":70538},{"artifact":0,"gen_end":60274,"gen_start":58637,"node":24,"role":"declaration","source":0,"src_end":72838,"src_start":71179},{"artifact":0,"gen_end":61944,"gen_start":60274,"node":25,"role":"declaration","source":0,"src_end":74784,"src_start":72840},{"artifact":0,"gen_end":62080,"gen_start":61944,"node":26,"role":"declaration","source":0,"src_end":74950,"src_start":74786},{"artifact":0,"gen_end":62443,"gen_start":62080,"node":27,"role":"declaration","source":0,"src_end":75383,"src_start":74952},{"artifact":0,"gen_end":63153,"gen_start":62443,"node":28,"role":"declaration","source":0,"src_end":76268,"src_start":75385},{"artifact":0,"gen_end":63575,"gen_start":63153,"node":29,"role":"declaration","source":0,"src_end":76725,"src_start":76270},{"artifact":0,"gen_end":64255,"gen_start":63575,"node":30,"role":"declaration","source":0,"src_end":77526,"src_start":76727},{"artifact":0,"gen_end":65239,"gen_start":64255,"node":31,"role":"declaration","source":0,"src_end":78480,"src_start":77528},{"artifact":0,"gen_end":65665,"gen_start":65239,"node":32,"role":"declaration","source":0,"src_end":78975,"src_start":78482},{"artifact":0,"gen_end":65922,"gen_start":65665,"node":33,"role":"declaration","source":0,"src_end":79432,"src_start":78977},{"artifact":0,"gen_end":82859,"gen_start":65922,"node":34,"role":"declaration","source":0,"src_end":98969,"src_start":79434},{"artifact":0,"gen_end":83963,"gen_start":82859,"node":35,"role":"declaration","source":0,"src_end":100183,"src_start":98971},{"artifact":0,"gen_end":85072,"gen_start":83963,"node":36,"role":"declaration","source":0,"src_end":101374,"src_start":100185},{"artifact":0,"gen_end":85915,"gen_start":85072,"node":37,"role":"declaration","source":0,"src_end":102359,"src_start":101376},{"artifact":0,"gen_end":86705,"gen_start":85915,"node":38,"role":"declaration","source":0,"src_end":103175,"src_start":102361},{"artifact":0,"gen_end":86958,"gen_start":86705,"node":39,"role":"declaration","source":0,"src_end":103487,"src_start":103177},{"artifact":0,"gen_end":86991,"gen_start":86958,"node":0,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":40,"role":"declaration","source":0,"src_end":103523,"src_start":0},{"artifact":1,"gen_end":517,"gen_start":134,"node":41,"role":"declaration","source":0,"src_end":477,"src_start":207},{"artifact":1,"gen_end":909,"gen_start":517,"node":42,"role":"declaration","source":0,"src_end":758,"src_start":479},{"artifact":1,"gen_end":1637,"gen_start":909,"node":43,"role":"declaration","source":0,"src_end":1236,"src_start":760},{"artifact":1,"gen_end":2483,"gen_start":1637,"node":44,"role":"declaration","source":0,"src_end":1827,"src_start":1238},{"artifact":1,"gen_end":3045,"gen_start":2483,"node":45,"role":"declaration","source":0,"src_end":2289,"src_start":1829},{"artifact":1,"gen_end":6011,"gen_start":3045,"node":46,"role":"declaration","source":0,"src_end":5469,"src_start":2291},{"artifact":1,"gen_end":8131,"gen_start":6011,"node":47,"role":"declaration","source":0,"src_end":7876,"src_start":5471},{"artifact":1,"gen_end":20493,"gen_start":8131,"node":48,"role":"declaration","source":0,"src_end":30493,"src_start":7878},{"artifact":1,"gen_end":21470,"gen_start":20493,"node":49,"role":"declaration","source":0,"src_end":31684,"src_start":30495},{"artifact":1,"gen_end":24882,"gen_start":21470,"node":50,"role":"declaration","source":0,"src_end":36293,"src_start":31686},{"artifact":1,"gen_end":29547,"gen_start":24882,"node":51,"role":"declaration","source":0,"src_end":40127,"src_start":36295},{"artifact":1,"gen_end":32362,"gen_start":29547,"node":52,"role":"declaration","source":0,"src_end":42351,"src_start":40129},{"artifact":1,"gen_end":35164,"gen_start":32362,"node":53,"role":"declaration","source":0,"src_end":44562,"src_start":42353},{"artifact":1,"gen_end":38287,"gen_start":35164,"node":54,"role":"declaration","source":0,"src_end":47097,"src_start":44564},{"artifact":1,"gen_end":48669,"gen_start":38287,"node":55,"role":"declaration","source":0,"src_end":57456,"src_start":47099},{"artifact":1,"gen_end":49118,"gen_start":48669,"node":56,"role":"declaration","source":0,"src_end":57756,"src_start":57458},{"artifact":1,"gen_end":52386,"gen_start":49118,"node":57,"role":"declaration","source":0,"src_end":61922,"src_start":57758},{"artifact":1,"gen_end":55206,"gen_start":52386,"node":58,"role":"declaration","source":0,"src_end":64151,"src_start":61924},{"artifact":1,"gen_end":56683,"gen_start":55206,"node":59,"role":"declaration","source":0,"src_end":65449,"src_start":64153},{"artifact":1,"gen_end":58161,"gen_start":56683,"node":60,"role":"declaration","source":0,"src_end":66748,"src_start":65451},{"artifact":1,"gen_end":59640,"gen_start":58161,"node":61,"role":"declaration","source":0,"src_end":68048,"src_start":66750},{"artifact":1,"gen_end":62550,"gen_start":59640,"node":62,"role":"declaration","source":0,"src_end":70536,"src_start":68050},{"artifact":1,"gen_end":63193,"gen_start":62550,"node":63,"role":"declaration","source":0,"src_end":71177,"src_start":70538},{"artifact":1,"gen_end":65057,"gen_start":63193,"node":64,"role":"declaration","source":0,"src_end":72838,"src_start":71179},{"artifact":1,"gen_end":66932,"gen_start":65057,"node":65,"role":"declaration","source":0,"src_end":74784,"src_start":72840},{"artifact":1,"gen_end":67250,"gen_start":66932,"node":66,"role":"declaration","source":0,"src_end":74950,"src_start":74786},{"artifact":1,"gen_end":67795,"gen_start":67250,"node":67,"role":"declaration","source":0,"src_end":75383,"src_start":74952},{"artifact":1,"gen_end":68689,"gen_start":67795,"node":68,"role":"declaration","source":0,"src_end":76268,"src_start":75385},{"artifact":1,"gen_end":69267,"gen_start":68689,"node":69,"role":"declaration","source":0,"src_end":76725,"src_start":76270},{"artifact":1,"gen_end":70111,"gen_start":69267,"node":70,"role":"declaration","source":0,"src_end":77526,"src_start":76727},{"artifact":1,"gen_end":71289,"gen_start":70111,"node":71,"role":"declaration","source":0,"src_end":78480,"src_start":77528},{"artifact":1,"gen_end":71897,"gen_start":71289,"node":72,"role":"declaration","source":0,"src_end":78975,"src_start":78482},{"artifact":1,"gen_end":72356,"gen_start":71897,"node":73,"role":"declaration","source":0,"src_end":79432,"src_start":78977},{"artifact":1,"gen_end":89648,"gen_start":72356,"node":74,"role":"declaration","source":0,"src_end":98969,"src_start":79434},{"artifact":1,"gen_end":90950,"gen_start":89648,"node":75,"role":"declaration","source":0,"src_end":100183,"src_start":98971},{"artifact":1,"gen_end":92270,"gen_start":90950,"node":76,"role":"declaration","source":0,"src_end":101374,"src_start":100185},{"artifact":1,"gen_end":93297,"gen_start":92270,"node":77,"role":"declaration","source":0,"src_end":102359,"src_start":101376},{"artifact":1,"gen_end":94295,"gen_start":93297,"node":78,"role":"declaration","source":0,"src_end":103175,"src_start":102361},{"artifact":1,"gen_end":94771,"gen_start":94295,"node":79,"role":"declaration","source":0,"src_end":103487,"src_start":103177},{"artifact":1,"gen_end":94786,"gen_start":94771,"node":40,"role":"declaration","source":0,"src_end":103523,"src_start":0}],"module":"RustSemantics","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-latex-module"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/RustSemantics.lex.tex","sha256":"183644ea3d81403440add2ca225c82d462dde21a7c5a7928d2c313a12e9242b3"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/RustSyntax.map.json b/compiler/expected/build/maps/LexLeanTarget/RustSyntax.map.json index 7ca2d3619..115422527 100644 --- a/compiler/expected/build/maps/LexLeanTarget/RustSyntax.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/RustSyntax.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/RustSyntax.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/RustSyntax.tex"}],"mappings":[{"artifact":0,"gen_end":248,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":0,"gen_end":382,"gen_start":248,"node":1,"role":"declaration","source":0,"src_end":529,"src_start":147},{"artifact":0,"gen_end":478,"gen_start":382,"node":2,"role":"declaration","source":0,"src_end":697,"src_start":531},{"artifact":0,"gen_end":865,"gen_start":478,"node":3,"role":"declaration","source":0,"src_end":1409,"src_start":699},{"artifact":0,"gen_end":1118,"gen_start":865,"node":4,"role":"declaration","source":0,"src_end":1807,"src_start":1411},{"artifact":0,"gen_end":1347,"gen_start":1118,"node":5,"role":"declaration","source":0,"src_end":2203,"src_start":1809},{"artifact":0,"gen_end":1601,"gen_start":1347,"node":6,"role":"declaration","source":0,"src_end":2656,"src_start":2205},{"artifact":0,"gen_end":2852,"gen_start":1601,"node":7,"role":"declaration","source":0,"src_end":4738,"src_start":2658},{"artifact":0,"gen_end":2929,"gen_start":2852,"node":8,"role":"declaration","source":0,"src_end":4892,"src_start":4740},{"artifact":0,"gen_end":3553,"gen_start":2929,"node":9,"role":"declaration","source":0,"src_end":5835,"src_start":4894},{"artifact":0,"gen_end":3633,"gen_start":3553,"node":10,"role":"declaration","source":0,"src_end":5988,"src_start":5837},{"artifact":0,"gen_end":3698,"gen_start":3633,"node":11,"role":"declaration","source":0,"src_end":6131,"src_start":5990},{"artifact":0,"gen_end":3759,"gen_start":3698,"node":12,"role":"declaration","source":0,"src_end":6266,"src_start":6133},{"artifact":0,"gen_end":3833,"gen_start":3759,"node":13,"role":"declaration","source":0,"src_end":6485,"src_start":6268},{"artifact":0,"gen_end":3941,"gen_start":3833,"node":14,"role":"declaration","source":0,"src_end":6696,"src_start":6487},{"artifact":0,"gen_end":4015,"gen_start":3941,"node":15,"role":"declaration","source":0,"src_end":6845,"src_start":6698},{"artifact":0,"gen_end":4083,"gen_start":4015,"node":16,"role":"declaration","source":0,"src_end":6988,"src_start":6847},{"artifact":0,"gen_end":4325,"gen_start":4083,"node":17,"role":"declaration","source":0,"src_end":7293,"src_start":6990},{"artifact":0,"gen_end":4374,"gen_start":4325,"node":18,"role":"declaration","source":0,"src_end":7433,"src_start":7295},{"artifact":0,"gen_end":4449,"gen_start":4374,"node":19,"role":"declaration","source":0,"src_end":7583,"src_start":7435},{"artifact":0,"gen_end":4479,"gen_start":4449,"node":0,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":20,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":1,"gen_end":712,"gen_start":134,"node":21,"role":"declaration","source":0,"src_end":529,"src_start":147},{"artifact":1,"gen_end":918,"gen_start":712,"node":22,"role":"declaration","source":0,"src_end":697,"src_start":531},{"artifact":1,"gen_end":2029,"gen_start":918,"node":23,"role":"declaration","source":0,"src_end":1409,"src_start":699},{"artifact":1,"gen_end":2627,"gen_start":2029,"node":24,"role":"declaration","source":0,"src_end":1807,"src_start":1411},{"artifact":1,"gen_end":3193,"gen_start":2627,"node":25,"role":"declaration","source":0,"src_end":2203,"src_start":1809},{"artifact":1,"gen_end":3877,"gen_start":3193,"node":26,"role":"declaration","source":0,"src_end":2656,"src_start":2205},{"artifact":1,"gen_end":7319,"gen_start":3877,"node":27,"role":"declaration","source":0,"src_end":4738,"src_start":2658},{"artifact":1,"gen_end":7511,"gen_start":7319,"node":28,"role":"declaration","source":0,"src_end":4892,"src_start":4740},{"artifact":1,"gen_end":8963,"gen_start":7511,"node":29,"role":"declaration","source":0,"src_end":5835,"src_start":4894},{"artifact":1,"gen_end":9153,"gen_start":8963,"node":30,"role":"declaration","source":0,"src_end":5988,"src_start":5837},{"artifact":1,"gen_end":9333,"gen_start":9153,"node":31,"role":"declaration","source":0,"src_end":6131,"src_start":5990},{"artifact":1,"gen_end":9505,"gen_start":9333,"node":32,"role":"declaration","source":0,"src_end":6266,"src_start":6133},{"artifact":1,"gen_end":9798,"gen_start":9505,"node":33,"role":"declaration","source":0,"src_end":6485,"src_start":6268},{"artifact":1,"gen_end":10053,"gen_start":9798,"node":34,"role":"declaration","source":0,"src_end":6696,"src_start":6487},{"artifact":1,"gen_end":10238,"gen_start":10053,"node":35,"role":"declaration","source":0,"src_end":6845,"src_start":6698},{"artifact":1,"gen_end":10417,"gen_start":10238,"node":36,"role":"declaration","source":0,"src_end":6988,"src_start":6847},{"artifact":1,"gen_end":10772,"gen_start":10417,"node":37,"role":"declaration","source":0,"src_end":7293,"src_start":6990},{"artifact":1,"gen_end":10950,"gen_start":10772,"node":38,"role":"declaration","source":0,"src_end":7433,"src_start":7295},{"artifact":1,"gen_end":11136,"gen_start":10950,"node":39,"role":"declaration","source":0,"src_end":7583,"src_start":7435},{"artifact":1,"gen_end":11151,"gen_start":11136,"node":20,"role":"declaration","source":0,"src_end":7619,"src_start":0}],"module":"RustSyntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-latex-module"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/RustSyntax.lex.tex","sha256":"9cbc4da6fc9441a03954f0979cbe4812aae0426811932e6ff1d6661043d3611f"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/RustSyntax.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/RustSyntax.tex"}],"mappings":[{"artifact":0,"gen_end":248,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":0,"gen_end":382,"gen_start":248,"node":1,"role":"declaration","source":0,"src_end":529,"src_start":147},{"artifact":0,"gen_end":478,"gen_start":382,"node":2,"role":"declaration","source":0,"src_end":697,"src_start":531},{"artifact":0,"gen_end":865,"gen_start":478,"node":3,"role":"declaration","source":0,"src_end":1409,"src_start":699},{"artifact":0,"gen_end":1118,"gen_start":865,"node":4,"role":"declaration","source":0,"src_end":1807,"src_start":1411},{"artifact":0,"gen_end":1347,"gen_start":1118,"node":5,"role":"declaration","source":0,"src_end":2203,"src_start":1809},{"artifact":0,"gen_end":1601,"gen_start":1347,"node":6,"role":"declaration","source":0,"src_end":2656,"src_start":2205},{"artifact":0,"gen_end":2852,"gen_start":1601,"node":7,"role":"declaration","source":0,"src_end":4738,"src_start":2658},{"artifact":0,"gen_end":2929,"gen_start":2852,"node":8,"role":"declaration","source":0,"src_end":4892,"src_start":4740},{"artifact":0,"gen_end":3553,"gen_start":2929,"node":9,"role":"declaration","source":0,"src_end":5835,"src_start":4894},{"artifact":0,"gen_end":3633,"gen_start":3553,"node":10,"role":"declaration","source":0,"src_end":5988,"src_start":5837},{"artifact":0,"gen_end":3698,"gen_start":3633,"node":11,"role":"declaration","source":0,"src_end":6131,"src_start":5990},{"artifact":0,"gen_end":3759,"gen_start":3698,"node":12,"role":"declaration","source":0,"src_end":6266,"src_start":6133},{"artifact":0,"gen_end":3833,"gen_start":3759,"node":13,"role":"declaration","source":0,"src_end":6485,"src_start":6268},{"artifact":0,"gen_end":3941,"gen_start":3833,"node":14,"role":"declaration","source":0,"src_end":6696,"src_start":6487},{"artifact":0,"gen_end":4015,"gen_start":3941,"node":15,"role":"declaration","source":0,"src_end":6845,"src_start":6698},{"artifact":0,"gen_end":4083,"gen_start":4015,"node":16,"role":"declaration","source":0,"src_end":6988,"src_start":6847},{"artifact":0,"gen_end":4325,"gen_start":4083,"node":17,"role":"declaration","source":0,"src_end":7293,"src_start":6990},{"artifact":0,"gen_end":4374,"gen_start":4325,"node":18,"role":"declaration","source":0,"src_end":7433,"src_start":7295},{"artifact":0,"gen_end":4449,"gen_start":4374,"node":19,"role":"declaration","source":0,"src_end":7583,"src_start":7435},{"artifact":0,"gen_end":4479,"gen_start":4449,"node":0,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":20,"role":"declaration","source":0,"src_end":7619,"src_start":0},{"artifact":1,"gen_end":712,"gen_start":134,"node":21,"role":"declaration","source":0,"src_end":529,"src_start":147},{"artifact":1,"gen_end":918,"gen_start":712,"node":22,"role":"declaration","source":0,"src_end":697,"src_start":531},{"artifact":1,"gen_end":2029,"gen_start":918,"node":23,"role":"declaration","source":0,"src_end":1409,"src_start":699},{"artifact":1,"gen_end":2627,"gen_start":2029,"node":24,"role":"declaration","source":0,"src_end":1807,"src_start":1411},{"artifact":1,"gen_end":3193,"gen_start":2627,"node":25,"role":"declaration","source":0,"src_end":2203,"src_start":1809},{"artifact":1,"gen_end":3877,"gen_start":3193,"node":26,"role":"declaration","source":0,"src_end":2656,"src_start":2205},{"artifact":1,"gen_end":7319,"gen_start":3877,"node":27,"role":"declaration","source":0,"src_end":4738,"src_start":2658},{"artifact":1,"gen_end":7511,"gen_start":7319,"node":28,"role":"declaration","source":0,"src_end":4892,"src_start":4740},{"artifact":1,"gen_end":8963,"gen_start":7511,"node":29,"role":"declaration","source":0,"src_end":5835,"src_start":4894},{"artifact":1,"gen_end":9153,"gen_start":8963,"node":30,"role":"declaration","source":0,"src_end":5988,"src_start":5837},{"artifact":1,"gen_end":9333,"gen_start":9153,"node":31,"role":"declaration","source":0,"src_end":6131,"src_start":5990},{"artifact":1,"gen_end":9505,"gen_start":9333,"node":32,"role":"declaration","source":0,"src_end":6266,"src_start":6133},{"artifact":1,"gen_end":9798,"gen_start":9505,"node":33,"role":"declaration","source":0,"src_end":6485,"src_start":6268},{"artifact":1,"gen_end":10053,"gen_start":9798,"node":34,"role":"declaration","source":0,"src_end":6696,"src_start":6487},{"artifact":1,"gen_end":10238,"gen_start":10053,"node":35,"role":"declaration","source":0,"src_end":6845,"src_start":6698},{"artifact":1,"gen_end":10417,"gen_start":10238,"node":36,"role":"declaration","source":0,"src_end":6988,"src_start":6847},{"artifact":1,"gen_end":10772,"gen_start":10417,"node":37,"role":"declaration","source":0,"src_end":7293,"src_start":6990},{"artifact":1,"gen_end":10950,"gen_start":10772,"node":38,"role":"declaration","source":0,"src_end":7433,"src_start":7295},{"artifact":1,"gen_end":11136,"gen_start":10950,"node":39,"role":"declaration","source":0,"src_end":7583,"src_start":7435},{"artifact":1,"gen_end":11151,"gen_start":11136,"node":20,"role":"declaration","source":0,"src_end":7619,"src_start":0}],"module":"RustSyntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-latex-module"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/RustSyntax.lex.tex","sha256":"9cbc4da6fc9441a03954f0979cbe4812aae0426811932e6ff1d6661043d3611f"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/ScreeningOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/ScreeningOracle.map.json index bb249e1bd..0a83ea767 100644 --- a/compiler/expected/build/maps/LexLeanTarget/ScreeningOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/ScreeningOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ScreeningOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ScreeningOracle.tex"}],"mappings":[{"artifact":0,"gen_end":400,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":0,"gen_end":526,"gen_start":400,"node":1,"role":"declaration","source":0,"src_end":254,"src_start":124},{"artifact":0,"gen_end":655,"gen_start":526,"node":2,"role":"declaration","source":0,"src_end":412,"src_start":256},{"artifact":0,"gen_end":3724,"gen_start":655,"node":3,"role":"declaration","source":0,"src_end":637,"src_start":414},{"artifact":0,"gen_end":3926,"gen_start":3724,"node":4,"role":"declaration","source":0,"src_end":877,"src_start":639},{"artifact":0,"gen_end":4191,"gen_start":3926,"node":5,"role":"declaration","source":0,"src_end":1179,"src_start":879},{"artifact":0,"gen_end":4310,"gen_start":4191,"node":6,"role":"declaration","source":0,"src_end":1276,"src_start":1181},{"artifact":0,"gen_end":4462,"gen_start":4310,"node":7,"role":"declaration","source":0,"src_end":1451,"src_start":1278},{"artifact":0,"gen_end":4463,"gen_start":4462,"node":8,"role":"declaration","source":0,"src_end":1543,"src_start":1453},{"artifact":0,"gen_end":7559,"gen_start":4463,"node":9,"role":"declaration","source":0,"src_end":1781,"src_start":1545},{"artifact":0,"gen_end":9004,"gen_start":7559,"node":10,"role":"declaration","source":0,"src_end":2191,"src_start":1783},{"artifact":0,"gen_end":9087,"gen_start":9004,"node":11,"role":"declaration","source":0,"src_end":2283,"src_start":2193},{"artifact":0,"gen_end":9173,"gen_start":9087,"node":12,"role":"declaration","source":0,"src_end":2411,"src_start":2285},{"artifact":0,"gen_end":12218,"gen_start":9173,"node":13,"role":"declaration","source":0,"src_end":2612,"src_start":2413},{"artifact":0,"gen_end":12405,"gen_start":12218,"node":14,"role":"declaration","source":0,"src_end":2795,"src_start":2614},{"artifact":0,"gen_end":21447,"gen_start":12405,"node":15,"role":"declaration","source":0,"src_end":3144,"src_start":2797},{"artifact":0,"gen_end":45902,"gen_start":21447,"node":16,"role":"declaration","source":0,"src_end":3584,"src_start":3146},{"artifact":0,"gen_end":45937,"gen_start":45902,"node":0,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":254,"src_start":124},{"artifact":1,"gen_end":805,"gen_start":430,"node":19,"role":"declaration","source":0,"src_end":412,"src_start":256},{"artifact":1,"gen_end":1090,"gen_start":805,"node":20,"role":"declaration","source":0,"src_end":637,"src_start":414},{"artifact":1,"gen_end":1752,"gen_start":1090,"node":21,"role":"declaration","source":0,"src_end":877,"src_start":639},{"artifact":1,"gen_end":2542,"gen_start":1752,"node":22,"role":"declaration","source":0,"src_end":1179,"src_start":879},{"artifact":1,"gen_end":2959,"gen_start":2542,"node":23,"role":"declaration","source":0,"src_end":1276,"src_start":1181},{"artifact":1,"gen_end":3312,"gen_start":2959,"node":24,"role":"declaration","source":0,"src_end":1451,"src_start":1278},{"artifact":1,"gen_end":3527,"gen_start":3312,"node":25,"role":"declaration","source":0,"src_end":1543,"src_start":1453},{"artifact":1,"gen_end":3850,"gen_start":3527,"node":26,"role":"declaration","source":0,"src_end":1781,"src_start":1545},{"artifact":1,"gen_end":5867,"gen_start":3850,"node":27,"role":"declaration","source":0,"src_end":2191,"src_start":1783},{"artifact":1,"gen_end":6121,"gen_start":5867,"node":28,"role":"declaration","source":0,"src_end":2283,"src_start":2193},{"artifact":1,"gen_end":6454,"gen_start":6121,"node":29,"role":"declaration","source":0,"src_end":2411,"src_start":2285},{"artifact":1,"gen_end":6717,"gen_start":6454,"node":30,"role":"declaration","source":0,"src_end":2612,"src_start":2413},{"artifact":1,"gen_end":7348,"gen_start":6717,"node":31,"role":"declaration","source":0,"src_end":2795,"src_start":2614},{"artifact":1,"gen_end":13192,"gen_start":7348,"node":32,"role":"declaration","source":0,"src_end":3144,"src_start":2797},{"artifact":1,"gen_end":27179,"gen_start":13192,"node":33,"role":"declaration","source":0,"src_end":3584,"src_start":3146},{"artifact":1,"gen_end":27194,"gen_start":27179,"node":17,"role":"declaration","source":0,"src_end":3620,"src_start":0}],"module":"ScreeningOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/ScreeningOracle.lex.tex","sha256":"23fe7cb8804846c5418204184105f7381f5f36ddd2cdd1beec466416b5d12cb9"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/ScreeningOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/ScreeningOracle.tex"}],"mappings":[{"artifact":0,"gen_end":400,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":0,"gen_end":526,"gen_start":400,"node":1,"role":"declaration","source":0,"src_end":254,"src_start":124},{"artifact":0,"gen_end":655,"gen_start":526,"node":2,"role":"declaration","source":0,"src_end":412,"src_start":256},{"artifact":0,"gen_end":3724,"gen_start":655,"node":3,"role":"declaration","source":0,"src_end":637,"src_start":414},{"artifact":0,"gen_end":3926,"gen_start":3724,"node":4,"role":"declaration","source":0,"src_end":877,"src_start":639},{"artifact":0,"gen_end":4191,"gen_start":3926,"node":5,"role":"declaration","source":0,"src_end":1179,"src_start":879},{"artifact":0,"gen_end":4310,"gen_start":4191,"node":6,"role":"declaration","source":0,"src_end":1276,"src_start":1181},{"artifact":0,"gen_end":4462,"gen_start":4310,"node":7,"role":"declaration","source":0,"src_end":1451,"src_start":1278},{"artifact":0,"gen_end":4463,"gen_start":4462,"node":8,"role":"declaration","source":0,"src_end":1543,"src_start":1453},{"artifact":0,"gen_end":7559,"gen_start":4463,"node":9,"role":"declaration","source":0,"src_end":1781,"src_start":1545},{"artifact":0,"gen_end":9004,"gen_start":7559,"node":10,"role":"declaration","source":0,"src_end":2191,"src_start":1783},{"artifact":0,"gen_end":9087,"gen_start":9004,"node":11,"role":"declaration","source":0,"src_end":2283,"src_start":2193},{"artifact":0,"gen_end":9173,"gen_start":9087,"node":12,"role":"declaration","source":0,"src_end":2411,"src_start":2285},{"artifact":0,"gen_end":12218,"gen_start":9173,"node":13,"role":"declaration","source":0,"src_end":2612,"src_start":2413},{"artifact":0,"gen_end":12405,"gen_start":12218,"node":14,"role":"declaration","source":0,"src_end":2795,"src_start":2614},{"artifact":0,"gen_end":21447,"gen_start":12405,"node":15,"role":"declaration","source":0,"src_end":3144,"src_start":2797},{"artifact":0,"gen_end":45902,"gen_start":21447,"node":16,"role":"declaration","source":0,"src_end":3584,"src_start":3146},{"artifact":0,"gen_end":45937,"gen_start":45902,"node":0,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3620,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":254,"src_start":124},{"artifact":1,"gen_end":805,"gen_start":430,"node":19,"role":"declaration","source":0,"src_end":412,"src_start":256},{"artifact":1,"gen_end":1090,"gen_start":805,"node":20,"role":"declaration","source":0,"src_end":637,"src_start":414},{"artifact":1,"gen_end":1752,"gen_start":1090,"node":21,"role":"declaration","source":0,"src_end":877,"src_start":639},{"artifact":1,"gen_end":2542,"gen_start":1752,"node":22,"role":"declaration","source":0,"src_end":1179,"src_start":879},{"artifact":1,"gen_end":2959,"gen_start":2542,"node":23,"role":"declaration","source":0,"src_end":1276,"src_start":1181},{"artifact":1,"gen_end":3312,"gen_start":2959,"node":24,"role":"declaration","source":0,"src_end":1451,"src_start":1278},{"artifact":1,"gen_end":3527,"gen_start":3312,"node":25,"role":"declaration","source":0,"src_end":1543,"src_start":1453},{"artifact":1,"gen_end":3850,"gen_start":3527,"node":26,"role":"declaration","source":0,"src_end":1781,"src_start":1545},{"artifact":1,"gen_end":5867,"gen_start":3850,"node":27,"role":"declaration","source":0,"src_end":2191,"src_start":1783},{"artifact":1,"gen_end":6121,"gen_start":5867,"node":28,"role":"declaration","source":0,"src_end":2283,"src_start":2193},{"artifact":1,"gen_end":6454,"gen_start":6121,"node":29,"role":"declaration","source":0,"src_end":2411,"src_start":2285},{"artifact":1,"gen_end":6717,"gen_start":6454,"node":30,"role":"declaration","source":0,"src_end":2612,"src_start":2413},{"artifact":1,"gen_end":7348,"gen_start":6717,"node":31,"role":"declaration","source":0,"src_end":2795,"src_start":2614},{"artifact":1,"gen_end":13192,"gen_start":7348,"node":32,"role":"declaration","source":0,"src_end":3144,"src_start":2797},{"artifact":1,"gen_end":27179,"gen_start":13192,"node":33,"role":"declaration","source":0,"src_end":3584,"src_start":3146},{"artifact":1,"gen_end":27194,"gen_start":27179,"node":17,"role":"declaration","source":0,"src_end":3620,"src_start":0}],"module":"ScreeningOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/ScreeningOracle.lex.tex","sha256":"23fe7cb8804846c5418204184105f7381f5f36ddd2cdd1beec466416b5d12cb9"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/TargetFixtures.map.json b/compiler/expected/build/maps/LexLeanTarget/TargetFixtures.map.json index a3e22235a..6c8972e9b 100644 --- a/compiler/expected/build/maps/LexLeanTarget/TargetFixtures.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/TargetFixtures.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":416,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":0,"gen_end":4776,"gen_start":416,"node":1,"role":"declaration","source":0,"src_end":3550,"src_start":210},{"artifact":0,"gen_end":4974,"gen_start":4776,"node":2,"role":"declaration","source":0,"src_end":3782,"src_start":3552},{"artifact":0,"gen_end":5139,"gen_start":4974,"node":3,"role":"declaration","source":0,"src_end":4028,"src_start":3784},{"artifact":0,"gen_end":10978,"gen_start":5139,"node":4,"role":"declaration","source":0,"src_end":8546,"src_start":4030},{"artifact":0,"gen_end":11228,"gen_start":10978,"node":5,"role":"declaration","source":0,"src_end":8824,"src_start":8548},{"artifact":0,"gen_end":11754,"gen_start":11228,"node":6,"role":"declaration","source":0,"src_end":9359,"src_start":8826},{"artifact":0,"gen_end":22707,"gen_start":11754,"node":7,"role":"declaration","source":0,"src_end":17744,"src_start":9361},{"artifact":0,"gen_end":23052,"gen_start":22707,"node":8,"role":"declaration","source":0,"src_end":18105,"src_start":17746},{"artifact":0,"gen_end":23903,"gen_start":23052,"node":9,"role":"declaration","source":0,"src_end":18893,"src_start":18107},{"artifact":0,"gen_end":27311,"gen_start":23903,"node":10,"role":"declaration","source":0,"src_end":21516,"src_start":18895},{"artifact":0,"gen_end":27600,"gen_start":27311,"node":11,"role":"declaration","source":0,"src_end":21827,"src_start":21518},{"artifact":0,"gen_end":28054,"gen_start":27600,"node":12,"role":"declaration","source":0,"src_end":22311,"src_start":21829},{"artifact":0,"gen_end":29437,"gen_start":28054,"node":13,"role":"declaration","source":0,"src_end":23401,"src_start":22313},{"artifact":0,"gen_end":29994,"gen_start":29437,"node":14,"role":"declaration","source":0,"src_end":23910,"src_start":23403},{"artifact":0,"gen_end":30151,"gen_start":29994,"node":15,"role":"declaration","source":0,"src_end":24148,"src_start":23912},{"artifact":0,"gen_end":33368,"gen_start":30151,"node":16,"role":"declaration","source":0,"src_end":26592,"src_start":24150},{"artifact":0,"gen_end":33562,"gen_start":33368,"node":17,"role":"declaration","source":0,"src_end":26820,"src_start":26594},{"artifact":0,"gen_end":39640,"gen_start":33562,"node":18,"role":"declaration","source":0,"src_end":31444,"src_start":26822},{"artifact":0,"gen_end":39830,"gen_start":39640,"node":19,"role":"declaration","source":0,"src_end":31668,"src_start":31446},{"artifact":0,"gen_end":42895,"gen_start":39830,"node":20,"role":"declaration","source":0,"src_end":34045,"src_start":31670},{"artifact":0,"gen_end":43087,"gen_start":42895,"node":21,"role":"declaration","source":0,"src_end":34271,"src_start":34047},{"artifact":0,"gen_end":43546,"gen_start":43087,"node":22,"role":"declaration","source":0,"src_end":34728,"src_start":34273},{"artifact":0,"gen_end":50575,"gen_start":43546,"node":23,"role":"declaration","source":0,"src_end":40112,"src_start":34730},{"artifact":0,"gen_end":50771,"gen_start":50575,"node":24,"role":"declaration","source":0,"src_end":40342,"src_start":40114},{"artifact":0,"gen_end":51714,"gen_start":50771,"node":25,"role":"declaration","source":0,"src_end":41184,"src_start":40344},{"artifact":0,"gen_end":54033,"gen_start":51714,"node":26,"role":"declaration","source":0,"src_end":43042,"src_start":41186},{"artifact":0,"gen_end":54374,"gen_start":54033,"node":27,"role":"declaration","source":0,"src_end":43399,"src_start":43044},{"artifact":0,"gen_end":54544,"gen_start":54374,"node":28,"role":"declaration","source":0,"src_end":43650,"src_start":43401},{"artifact":0,"gen_end":58191,"gen_start":54544,"node":29,"role":"declaration","source":0,"src_end":46530,"src_start":43652},{"artifact":0,"gen_end":58492,"gen_start":58191,"node":30,"role":"declaration","source":0,"src_end":46853,"src_start":46532},{"artifact":0,"gen_end":58744,"gen_start":58492,"node":31,"role":"declaration","source":0,"src_end":47168,"src_start":46855},{"artifact":0,"gen_end":60381,"gen_start":58744,"node":32,"role":"declaration","source":0,"src_end":48492,"src_start":47170},{"artifact":0,"gen_end":60672,"gen_start":60381,"node":33,"role":"declaration","source":0,"src_end":48805,"src_start":48494},{"artifact":0,"gen_end":60838,"gen_start":60672,"node":34,"role":"declaration","source":0,"src_end":49052,"src_start":48807},{"artifact":0,"gen_end":63484,"gen_start":60838,"node":35,"role":"declaration","source":0,"src_end":51097,"src_start":49054},{"artifact":0,"gen_end":63734,"gen_start":63484,"node":36,"role":"declaration","source":0,"src_end":51375,"src_start":51099},{"artifact":0,"gen_end":63904,"gen_start":63734,"node":37,"role":"declaration","source":0,"src_end":51626,"src_start":51377},{"artifact":0,"gen_end":66452,"gen_start":63904,"node":38,"role":"declaration","source":0,"src_end":53608,"src_start":51628},{"artifact":0,"gen_end":66706,"gen_start":66452,"node":39,"role":"declaration","source":0,"src_end":53890,"src_start":53610},{"artifact":0,"gen_end":66879,"gen_start":66706,"node":40,"role":"declaration","source":0,"src_end":54144,"src_start":53892},{"artifact":0,"gen_end":68110,"gen_start":66879,"node":41,"role":"declaration","source":0,"src_end":55131,"src_start":54146},{"artifact":0,"gen_end":68352,"gen_start":68110,"node":42,"role":"declaration","source":0,"src_end":55401,"src_start":55133},{"artifact":0,"gen_end":68612,"gen_start":68352,"node":43,"role":"declaration","source":0,"src_end":55713,"src_start":55403},{"artifact":0,"gen_end":71633,"gen_start":68612,"node":44,"role":"declaration","source":0,"src_end":58081,"src_start":55715},{"artifact":0,"gen_end":72098,"gen_start":71633,"node":45,"role":"declaration","source":0,"src_end":58529,"src_start":58083},{"artifact":0,"gen_end":72439,"gen_start":72098,"node":46,"role":"declaration","source":0,"src_end":58912,"src_start":58531},{"artifact":0,"gen_end":76869,"gen_start":72439,"node":47,"role":"declaration","source":0,"src_end":62449,"src_start":58914},{"artifact":0,"gen_end":77055,"gen_start":76869,"node":48,"role":"declaration","source":0,"src_end":62669,"src_start":62451},{"artifact":0,"gen_end":77851,"gen_start":77055,"node":49,"role":"declaration","source":0,"src_end":63451,"src_start":62671},{"artifact":0,"gen_end":88821,"gen_start":77851,"node":50,"role":"declaration","source":0,"src_end":71974,"src_start":63453},{"artifact":0,"gen_end":89007,"gen_start":88821,"node":51,"role":"declaration","source":0,"src_end":72194,"src_start":71976},{"artifact":0,"gen_end":89796,"gen_start":89007,"node":52,"role":"declaration","source":0,"src_end":72834,"src_start":72196},{"artifact":0,"gen_end":89998,"gen_start":89796,"node":53,"role":"declaration","source":0,"src_end":73070,"src_start":72836},{"artifact":0,"gen_end":90813,"gen_start":89998,"node":54,"role":"declaration","source":0,"src_end":73736,"src_start":73072},{"artifact":0,"gen_end":91023,"gen_start":90813,"node":55,"role":"declaration","source":0,"src_end":73980,"src_start":73738},{"artifact":0,"gen_end":96468,"gen_start":91023,"node":56,"role":"declaration","source":0,"src_end":78216,"src_start":73982},{"artifact":0,"gen_end":96656,"gen_start":96468,"node":57,"role":"declaration","source":0,"src_end":78438,"src_start":78218},{"artifact":0,"gen_end":97209,"gen_start":96656,"node":58,"role":"declaration","source":0,"src_end":79009,"src_start":78440},{"artifact":0,"gen_end":98982,"gen_start":97209,"node":59,"role":"declaration","source":0,"src_end":80400,"src_start":79011},{"artifact":0,"gen_end":99244,"gen_start":98982,"node":60,"role":"declaration","source":0,"src_end":80690,"src_start":80402},{"artifact":0,"gen_end":99430,"gen_start":99244,"node":61,"role":"declaration","source":0,"src_end":80957,"src_start":80692},{"artifact":0,"gen_end":106934,"gen_start":99430,"node":62,"role":"declaration","source":0,"src_end":86862,"src_start":80959},{"artifact":0,"gen_end":107136,"gen_start":106934,"node":63,"role":"declaration","source":0,"src_end":87098,"src_start":86864},{"artifact":0,"gen_end":108073,"gen_start":107136,"node":64,"role":"declaration","source":0,"src_end":87978,"src_start":87100},{"artifact":0,"gen_end":115547,"gen_start":108073,"node":65,"role":"declaration","source":0,"src_end":93861,"src_start":87980},{"artifact":0,"gen_end":115753,"gen_start":115547,"node":66,"role":"declaration","source":0,"src_end":94101,"src_start":93863},{"artifact":0,"gen_end":116603,"gen_start":115753,"node":67,"role":"declaration","source":0,"src_end":94912,"src_start":94103},{"artifact":0,"gen_end":129817,"gen_start":116603,"node":68,"role":"declaration","source":0,"src_end":105303,"src_start":94914},{"artifact":0,"gen_end":130025,"gen_start":129817,"node":69,"role":"declaration","source":0,"src_end":105545,"src_start":105305},{"artifact":0,"gen_end":131476,"gen_start":130025,"node":70,"role":"declaration","source":0,"src_end":106810,"src_start":105547},{"artifact":0,"gen_end":139629,"gen_start":131476,"node":71,"role":"declaration","source":0,"src_end":113236,"src_start":106812},{"artifact":0,"gen_end":139837,"gen_start":139629,"node":72,"role":"declaration","source":0,"src_end":113478,"src_start":113238},{"artifact":0,"gen_end":140698,"gen_start":139837,"node":73,"role":"declaration","source":0,"src_end":114319,"src_start":113480},{"artifact":0,"gen_end":151786,"gen_start":140698,"node":74,"role":"declaration","source":0,"src_end":123112,"src_start":114321},{"artifact":0,"gen_end":151990,"gen_start":151786,"node":75,"role":"declaration","source":0,"src_end":123350,"src_start":123114},{"artifact":0,"gen_end":153140,"gen_start":151990,"node":76,"role":"declaration","source":0,"src_end":124433,"src_start":123352},{"artifact":0,"gen_end":154634,"gen_start":153140,"node":77,"role":"declaration","source":0,"src_end":125634,"src_start":124435},{"artifact":0,"gen_end":154952,"gen_start":154634,"node":78,"role":"declaration","source":0,"src_end":125974,"src_start":125636},{"artifact":0,"gen_end":156446,"gen_start":154952,"node":79,"role":"declaration","source":0,"src_end":127175,"src_start":125976},{"artifact":0,"gen_end":156774,"gen_start":156446,"node":80,"role":"declaration","source":0,"src_end":127525,"src_start":127177},{"artifact":0,"gen_end":158268,"gen_start":156774,"node":81,"role":"declaration","source":0,"src_end":128726,"src_start":127527},{"artifact":0,"gen_end":158614,"gen_start":158268,"node":82,"role":"declaration","source":0,"src_end":129094,"src_start":128728},{"artifact":0,"gen_end":160103,"gen_start":158614,"node":83,"role":"declaration","source":0,"src_end":130290,"src_start":129096},{"artifact":0,"gen_end":160413,"gen_start":160103,"node":84,"role":"declaration","source":0,"src_end":130622,"src_start":130292},{"artifact":0,"gen_end":161907,"gen_start":160413,"node":85,"role":"declaration","source":0,"src_end":131823,"src_start":130624},{"artifact":0,"gen_end":162221,"gen_start":161907,"node":86,"role":"declaration","source":0,"src_end":132159,"src_start":131825},{"artifact":0,"gen_end":163715,"gen_start":162221,"node":87,"role":"declaration","source":0,"src_end":133360,"src_start":132161},{"artifact":0,"gen_end":164034,"gen_start":163715,"node":88,"role":"declaration","source":0,"src_end":133701,"src_start":133362},{"artifact":0,"gen_end":165528,"gen_start":164034,"node":89,"role":"declaration","source":0,"src_end":134902,"src_start":133703},{"artifact":0,"gen_end":165857,"gen_start":165528,"node":90,"role":"declaration","source":0,"src_end":135253,"src_start":134904},{"artifact":0,"gen_end":167346,"gen_start":165857,"node":91,"role":"declaration","source":0,"src_end":136449,"src_start":135255},{"artifact":0,"gen_end":167654,"gen_start":167346,"node":92,"role":"declaration","source":0,"src_end":136779,"src_start":136451},{"artifact":0,"gen_end":190136,"gen_start":167654,"node":93,"role":"declaration","source":0,"src_end":154522,"src_start":136781},{"artifact":0,"gen_end":190512,"gen_start":190136,"node":94,"role":"declaration","source":0,"src_end":154914,"src_start":154524},{"artifact":0,"gen_end":192232,"gen_start":190512,"node":95,"role":"declaration","source":0,"src_end":156415,"src_start":154916},{"artifact":0,"gen_end":214714,"gen_start":192232,"node":96,"role":"declaration","source":0,"src_end":174158,"src_start":156417},{"artifact":0,"gen_end":215100,"gen_start":214714,"node":97,"role":"declaration","source":0,"src_end":174560,"src_start":174160},{"artifact":0,"gen_end":216835,"gen_start":215100,"node":98,"role":"declaration","source":0,"src_end":176076,"src_start":174562},{"artifact":0,"gen_end":239317,"gen_start":216835,"node":99,"role":"declaration","source":0,"src_end":193819,"src_start":176078},{"artifact":0,"gen_end":239721,"gen_start":239317,"node":100,"role":"declaration","source":0,"src_end":194239,"src_start":193821},{"artifact":0,"gen_end":241484,"gen_start":239721,"node":101,"role":"declaration","source":0,"src_end":195783,"src_start":194241},{"artifact":0,"gen_end":263857,"gen_start":241484,"node":102,"role":"declaration","source":0,"src_end":213417,"src_start":195785},{"artifact":0,"gen_end":264223,"gen_start":263857,"node":103,"role":"declaration","source":0,"src_end":213799,"src_start":213419},{"artifact":0,"gen_end":265862,"gen_start":264223,"node":104,"role":"declaration","source":0,"src_end":215229,"src_start":213801},{"artifact":0,"gen_end":285904,"gen_start":265862,"node":105,"role":"declaration","source":0,"src_end":231048,"src_start":215231},{"artifact":0,"gen_end":286277,"gen_start":285904,"node":106,"role":"declaration","source":0,"src_end":231437,"src_start":231050},{"artifact":0,"gen_end":287825,"gen_start":286277,"node":107,"role":"declaration","source":0,"src_end":232802,"src_start":231439},{"artifact":0,"gen_end":307867,"gen_start":287825,"node":108,"role":"declaration","source":0,"src_end":248621,"src_start":232804},{"artifact":0,"gen_end":308245,"gen_start":307867,"node":109,"role":"declaration","source":0,"src_end":249015,"src_start":248623},{"artifact":0,"gen_end":309818,"gen_start":308245,"node":110,"role":"declaration","source":0,"src_end":250405,"src_start":249017},{"artifact":0,"gen_end":329860,"gen_start":309818,"node":111,"role":"declaration","source":0,"src_end":266224,"src_start":250407},{"artifact":0,"gen_end":330248,"gen_start":329860,"node":112,"role":"declaration","source":0,"src_end":266628,"src_start":266226},{"artifact":0,"gen_end":331870,"gen_start":330248,"node":113,"role":"declaration","source":0,"src_end":268067,"src_start":266630},{"artifact":0,"gen_end":351817,"gen_start":331870,"node":114,"role":"declaration","source":0,"src_end":283791,"src_start":268069},{"artifact":0,"gen_end":352182,"gen_start":351817,"node":115,"role":"declaration","source":0,"src_end":284172,"src_start":283793},{"artifact":0,"gen_end":353647,"gen_start":352182,"node":116,"role":"declaration","source":0,"src_end":285464,"src_start":284174},{"artifact":0,"gen_end":371515,"gen_start":353647,"node":117,"role":"declaration","source":0,"src_end":299241,"src_start":285466},{"artifact":0,"gen_end":371715,"gen_start":371515,"node":118,"role":"declaration","source":0,"src_end":299475,"src_start":299243},{"artifact":0,"gen_end":372664,"gen_start":371715,"node":119,"role":"declaration","source":0,"src_end":300339,"src_start":299477},{"artifact":0,"gen_end":399642,"gen_start":372664,"node":120,"role":"declaration","source":0,"src_end":321194,"src_start":300341},{"artifact":0,"gen_end":400865,"gen_start":399642,"node":121,"role":"declaration","source":0,"src_end":322214,"src_start":321196},{"artifact":0,"gen_end":401263,"gen_start":400865,"node":122,"role":"declaration","source":0,"src_end":322648,"src_start":322216},{"artifact":0,"gen_end":401650,"gen_start":401263,"node":123,"role":"declaration","source":0,"src_end":323189,"src_start":322650},{"artifact":0,"gen_end":428634,"gen_start":401650,"node":124,"role":"declaration","source":0,"src_end":344050,"src_start":323191},{"artifact":0,"gen_end":429869,"gen_start":428634,"node":125,"role":"declaration","source":0,"src_end":345082,"src_start":344052},{"artifact":0,"gen_end":430140,"gen_start":429869,"node":126,"role":"declaration","source":0,"src_end":345407,"src_start":345084},{"artifact":0,"gen_end":430538,"gen_start":430140,"node":127,"role":"declaration","source":0,"src_end":345959,"src_start":345409},{"artifact":0,"gen_end":457521,"gen_start":430538,"node":128,"role":"declaration","source":0,"src_end":366819,"src_start":345961},{"artifact":0,"gen_end":458754,"gen_start":457521,"node":129,"role":"declaration","source":0,"src_end":367849,"src_start":366821},{"artifact":0,"gen_end":459070,"gen_start":458754,"node":130,"role":"declaration","source":0,"src_end":368213,"src_start":367851},{"artifact":0,"gen_end":459467,"gen_start":459070,"node":131,"role":"declaration","source":0,"src_end":368764,"src_start":368215},{"artifact":0,"gen_end":464316,"gen_start":459467,"node":132,"role":"declaration","source":0,"src_end":372530,"src_start":368766},{"artifact":0,"gen_end":465541,"gen_start":464316,"node":133,"role":"declaration","source":0,"src_end":373552,"src_start":372532},{"artifact":0,"gen_end":465847,"gen_start":465541,"node":134,"role":"declaration","source":0,"src_end":373906,"src_start":373554},{"artifact":0,"gen_end":466235,"gen_start":465847,"node":135,"role":"declaration","source":0,"src_end":374448,"src_start":373908},{"artifact":0,"gen_end":471090,"gen_start":466235,"node":136,"role":"declaration","source":0,"src_end":378220,"src_start":374450},{"artifact":0,"gen_end":472327,"gen_start":471090,"node":137,"role":"declaration","source":0,"src_end":379254,"src_start":378222},{"artifact":0,"gen_end":472554,"gen_start":472327,"node":138,"role":"declaration","source":0,"src_end":379541,"src_start":379256},{"artifact":0,"gen_end":472955,"gen_start":472554,"node":139,"role":"declaration","source":0,"src_end":380096,"src_start":379543},{"artifact":0,"gen_end":499241,"gen_start":472955,"node":140,"role":"declaration","source":0,"src_end":400342,"src_start":380098},{"artifact":0,"gen_end":500422,"gen_start":499241,"node":141,"role":"declaration","source":0,"src_end":401326,"src_start":400344},{"artifact":0,"gen_end":500864,"gen_start":500422,"node":142,"role":"declaration","source":0,"src_end":401796,"src_start":401328},{"artifact":0,"gen_end":501351,"gen_start":500864,"node":143,"role":"declaration","source":0,"src_end":402462,"src_start":401798},{"artifact":0,"gen_end":527642,"gen_start":501351,"node":144,"role":"declaration","source":0,"src_end":422713,"src_start":402464},{"artifact":0,"gen_end":528612,"gen_start":527642,"node":145,"role":"declaration","source":0,"src_end":423537,"src_start":422715},{"artifact":0,"gen_end":528791,"gen_start":528612,"node":146,"role":"declaration","source":0,"src_end":423799,"src_start":423539},{"artifact":0,"gen_end":529276,"gen_start":528791,"node":147,"role":"declaration","source":0,"src_end":424408,"src_start":423801},{"artifact":0,"gen_end":538676,"gen_start":529276,"node":148,"role":"declaration","source":0,"src_end":431829,"src_start":424410},{"artifact":0,"gen_end":538874,"gen_start":538676,"node":149,"role":"declaration","source":0,"src_end":432061,"src_start":431831},{"artifact":0,"gen_end":539816,"gen_start":538874,"node":150,"role":"declaration","source":0,"src_end":432985,"src_start":432063},{"artifact":0,"gen_end":540653,"gen_start":539816,"node":151,"role":"declaration","source":0,"src_end":433667,"src_start":432987},{"artifact":0,"gen_end":540853,"gen_start":540653,"node":152,"role":"declaration","source":0,"src_end":433901,"src_start":433669},{"artifact":0,"gen_end":540978,"gen_start":540853,"node":153,"role":"declaration","source":0,"src_end":434117,"src_start":433903},{"artifact":0,"gen_end":541686,"gen_start":540978,"node":154,"role":"declaration","source":0,"src_end":434692,"src_start":434119},{"artifact":0,"gen_end":541886,"gen_start":541686,"node":155,"role":"declaration","source":0,"src_end":434926,"src_start":434694},{"artifact":0,"gen_end":542011,"gen_start":541886,"node":156,"role":"declaration","source":0,"src_end":435142,"src_start":434928},{"artifact":0,"gen_end":542982,"gen_start":542011,"node":157,"role":"declaration","source":0,"src_end":435936,"src_start":435144},{"artifact":0,"gen_end":543184,"gen_start":542982,"node":158,"role":"declaration","source":0,"src_end":436172,"src_start":435938},{"artifact":0,"gen_end":543311,"gen_start":543184,"node":159,"role":"declaration","source":0,"src_end":436390,"src_start":436174},{"artifact":0,"gen_end":544149,"gen_start":543311,"node":160,"role":"declaration","source":0,"src_end":437073,"src_start":436392},{"artifact":0,"gen_end":544349,"gen_start":544149,"node":161,"role":"declaration","source":0,"src_end":437307,"src_start":437075},{"artifact":0,"gen_end":544474,"gen_start":544349,"node":162,"role":"declaration","source":0,"src_end":437523,"src_start":437309},{"artifact":0,"gen_end":547049,"gen_start":544474,"node":163,"role":"declaration","source":0,"src_end":439549,"src_start":437525},{"artifact":0,"gen_end":547282,"gen_start":547049,"node":164,"role":"declaration","source":0,"src_end":439810,"src_start":439551},{"artifact":0,"gen_end":547436,"gen_start":547282,"node":165,"role":"declaration","source":0,"src_end":440045,"src_start":439812},{"artifact":0,"gen_end":547666,"gen_start":547436,"node":166,"role":"declaration","source":0,"src_end":440336,"src_start":440047},{"artifact":0,"gen_end":552599,"gen_start":547666,"node":167,"role":"declaration","source":0,"src_end":444150,"src_start":440338},{"artifact":0,"gen_end":552843,"gen_start":552599,"node":168,"role":"declaration","source":0,"src_end":444422,"src_start":444152},{"artifact":0,"gen_end":553093,"gen_start":552843,"node":169,"role":"declaration","source":0,"src_end":444735,"src_start":444424},{"artifact":0,"gen_end":553673,"gen_start":553093,"node":170,"role":"declaration","source":0,"src_end":445365,"src_start":444737},{"artifact":0,"gen_end":558613,"gen_start":553673,"node":171,"role":"declaration","source":0,"src_end":449186,"src_start":445367},{"artifact":0,"gen_end":558870,"gen_start":558613,"node":172,"role":"declaration","source":0,"src_end":449471,"src_start":449188},{"artifact":0,"gen_end":559134,"gen_start":558870,"node":173,"role":"declaration","source":0,"src_end":449798,"src_start":449473},{"artifact":0,"gen_end":559725,"gen_start":559134,"node":174,"role":"declaration","source":0,"src_end":450439,"src_start":449800},{"artifact":0,"gen_end":560577,"gen_start":559725,"node":175,"role":"declaration","source":0,"src_end":451140,"src_start":450441},{"artifact":0,"gen_end":562831,"gen_start":560577,"node":176,"role":"declaration","source":0,"src_end":453134,"src_start":451142},{"artifact":0,"gen_end":564913,"gen_start":562831,"node":177,"role":"declaration","source":0,"src_end":455036,"src_start":453136},{"artifact":0,"gen_end":568109,"gen_start":564913,"node":178,"role":"declaration","source":0,"src_end":457573,"src_start":455038},{"artifact":0,"gen_end":568544,"gen_start":568109,"node":179,"role":"declaration","source":0,"src_end":457997,"src_start":457575},{"artifact":0,"gen_end":568700,"gen_start":568544,"node":180,"role":"declaration","source":0,"src_end":458234,"src_start":457999},{"artifact":0,"gen_end":569069,"gen_start":568700,"node":181,"role":"declaration","source":0,"src_end":458637,"src_start":458236},{"artifact":0,"gen_end":575516,"gen_start":569069,"node":182,"role":"declaration","source":0,"src_end":463681,"src_start":458639},{"artifact":0,"gen_end":575928,"gen_start":575516,"node":183,"role":"declaration","source":0,"src_end":464082,"src_start":463683},{"artifact":0,"gen_end":576933,"gen_start":575928,"node":184,"role":"declaration","source":0,"src_end":464988,"src_start":464084},{"artifact":0,"gen_end":583626,"gen_start":576933,"node":185,"role":"declaration","source":0,"src_end":470464,"src_start":464990},{"artifact":0,"gen_end":583814,"gen_start":583626,"node":186,"role":"declaration","source":0,"src_end":470686,"src_start":470466},{"artifact":0,"gen_end":585760,"gen_start":583814,"node":187,"role":"declaration","source":0,"src_end":472433,"src_start":470688},{"artifact":0,"gen_end":590280,"gen_start":585760,"node":188,"role":"declaration","source":0,"src_end":475937,"src_start":472435},{"artifact":0,"gen_end":590881,"gen_start":590280,"node":189,"role":"declaration","source":0,"src_end":476491,"src_start":475939},{"artifact":0,"gen_end":591045,"gen_start":590881,"node":190,"role":"declaration","source":0,"src_end":476736,"src_start":476493},{"artifact":0,"gen_end":591301,"gen_start":591045,"node":191,"role":"declaration","source":0,"src_end":477112,"src_start":476738},{"artifact":0,"gen_end":594687,"gen_start":591301,"node":192,"role":"declaration","source":0,"src_end":479803,"src_start":477114},{"artifact":0,"gen_end":595234,"gen_start":594687,"node":193,"role":"declaration","source":0,"src_end":480309,"src_start":479805},{"artifact":0,"gen_end":595388,"gen_start":595234,"node":194,"role":"declaration","source":0,"src_end":480544,"src_start":480311},{"artifact":0,"gen_end":595740,"gen_start":595388,"node":195,"role":"declaration","source":0,"src_end":481002,"src_start":480546},{"artifact":0,"gen_end":601351,"gen_start":595740,"node":196,"role":"declaration","source":0,"src_end":485403,"src_start":481004},{"artifact":0,"gen_end":601999,"gen_start":601351,"node":197,"role":"declaration","source":0,"src_end":485998,"src_start":485405},{"artifact":0,"gen_end":602603,"gen_start":601999,"node":198,"role":"declaration","source":0,"src_end":486590,"src_start":486000},{"artifact":0,"gen_end":602992,"gen_start":602603,"node":199,"role":"declaration","source":0,"src_end":487052,"src_start":486592},{"artifact":0,"gen_end":608607,"gen_start":602992,"node":200,"role":"declaration","source":0,"src_end":491457,"src_start":487054},{"artifact":0,"gen_end":609263,"gen_start":608607,"node":201,"role":"declaration","source":0,"src_end":492060,"src_start":491459},{"artifact":0,"gen_end":609875,"gen_start":609263,"node":202,"role":"declaration","source":0,"src_end":492660,"src_start":492062},{"artifact":0,"gen_end":610272,"gen_start":609875,"node":203,"role":"declaration","source":0,"src_end":493130,"src_start":492662},{"artifact":0,"gen_end":615890,"gen_start":610272,"node":204,"role":"declaration","source":0,"src_end":497538,"src_start":493132},{"artifact":0,"gen_end":616552,"gen_start":615890,"node":205,"role":"declaration","source":0,"src_end":498147,"src_start":497540},{"artifact":0,"gen_end":617036,"gen_start":616552,"node":206,"role":"declaration","source":0,"src_end":498643,"src_start":498149},{"artifact":0,"gen_end":617439,"gen_start":617036,"node":207,"role":"declaration","source":0,"src_end":499119,"src_start":498645},{"artifact":0,"gen_end":619622,"gen_start":617439,"node":208,"role":"declaration","source":0,"src_end":500822,"src_start":499121},{"artifact":0,"gen_end":620169,"gen_start":619622,"node":209,"role":"declaration","source":0,"src_end":501328,"src_start":500824},{"artifact":0,"gen_end":620459,"gen_start":620169,"node":210,"role":"declaration","source":0,"src_end":501666,"src_start":501330},{"artifact":0,"gen_end":620745,"gen_start":620459,"node":211,"role":"declaration","source":0,"src_end":502061,"src_start":501668},{"artifact":0,"gen_end":624064,"gen_start":620745,"node":212,"role":"declaration","source":0,"src_end":504649,"src_start":502063},{"artifact":0,"gen_end":624661,"gen_start":624064,"node":213,"role":"declaration","source":0,"src_end":505199,"src_start":504651},{"artifact":0,"gen_end":624862,"gen_start":624661,"node":214,"role":"declaration","source":0,"src_end":505473,"src_start":505201},{"artifact":0,"gen_end":625262,"gen_start":624862,"node":215,"role":"declaration","source":0,"src_end":505990,"src_start":505475},{"artifact":0,"gen_end":628587,"gen_start":625262,"node":216,"role":"declaration","source":0,"src_end":508584,"src_start":505992},{"artifact":0,"gen_end":629196,"gen_start":628587,"node":217,"role":"declaration","source":0,"src_end":509146,"src_start":508586},{"artifact":0,"gen_end":629361,"gen_start":629196,"node":218,"role":"declaration","source":0,"src_end":509394,"src_start":509148},{"artifact":0,"gen_end":629773,"gen_start":629361,"node":219,"role":"declaration","source":0,"src_end":509923,"src_start":509396},{"artifact":0,"gen_end":633357,"gen_start":629773,"node":220,"role":"declaration","source":0,"src_end":512727,"src_start":509925},{"artifact":0,"gen_end":633954,"gen_start":633357,"node":221,"role":"declaration","source":0,"src_end":513277,"src_start":512729},{"artifact":0,"gen_end":634290,"gen_start":633954,"node":222,"role":"declaration","source":0,"src_end":513649,"src_start":513279},{"artifact":0,"gen_end":634673,"gen_start":634290,"node":223,"role":"declaration","source":0,"src_end":514107,"src_start":513651},{"artifact":0,"gen_end":638263,"gen_start":634673,"node":224,"role":"declaration","source":0,"src_end":516917,"src_start":514109},{"artifact":0,"gen_end":638872,"gen_start":638263,"node":225,"role":"declaration","source":0,"src_end":517479,"src_start":516919},{"artifact":0,"gen_end":639354,"gen_start":638872,"node":226,"role":"declaration","source":0,"src_end":517973,"src_start":517481},{"artifact":0,"gen_end":639749,"gen_start":639354,"node":227,"role":"declaration","source":0,"src_end":518443,"src_start":517975},{"artifact":0,"gen_end":641950,"gen_start":639749,"node":228,"role":"declaration","source":0,"src_end":520164,"src_start":518445},{"artifact":0,"gen_end":642501,"gen_start":641950,"node":229,"role":"declaration","source":0,"src_end":520674,"src_start":520166},{"artifact":0,"gen_end":642805,"gen_start":642501,"node":230,"role":"declaration","source":0,"src_end":521026,"src_start":520676},{"artifact":0,"gen_end":643103,"gen_start":642805,"node":231,"role":"declaration","source":0,"src_end":521433,"src_start":521028},{"artifact":0,"gen_end":657113,"gen_start":643103,"node":232,"role":"declaration","source":0,"src_end":532181,"src_start":521435},{"artifact":0,"gen_end":657714,"gen_start":657113,"node":233,"role":"declaration","source":0,"src_end":532741,"src_start":532183},{"artifact":0,"gen_end":658750,"gen_start":657714,"node":234,"role":"declaration","source":0,"src_end":533667,"src_start":532743},{"artifact":0,"gen_end":668664,"gen_start":658750,"node":235,"role":"declaration","source":0,"src_end":541388,"src_start":533669},{"artifact":0,"gen_end":668862,"gen_start":668664,"node":236,"role":"declaration","source":0,"src_end":541620,"src_start":541390},{"artifact":0,"gen_end":669893,"gen_start":668862,"node":237,"role":"declaration","source":0,"src_end":542588,"src_start":541622},{"artifact":0,"gen_end":670715,"gen_start":669893,"node":238,"role":"declaration","source":0,"src_end":543255,"src_start":542590},{"artifact":0,"gen_end":670915,"gen_start":670715,"node":239,"role":"declaration","source":0,"src_end":543489,"src_start":543257},{"artifact":0,"gen_end":671040,"gen_start":670915,"node":240,"role":"declaration","source":0,"src_end":543705,"src_start":543491},{"artifact":0,"gen_end":671861,"gen_start":671040,"node":241,"role":"declaration","source":0,"src_end":544371,"src_start":543707},{"artifact":0,"gen_end":672061,"gen_start":671861,"node":242,"role":"declaration","source":0,"src_end":544605,"src_start":544373},{"artifact":0,"gen_end":672186,"gen_start":672061,"node":243,"role":"declaration","source":0,"src_end":544821,"src_start":544607},{"artifact":0,"gen_end":673264,"gen_start":672186,"node":244,"role":"declaration","source":0,"src_end":545687,"src_start":544823},{"artifact":0,"gen_end":673470,"gen_start":673264,"node":245,"role":"declaration","source":0,"src_end":545927,"src_start":545689},{"artifact":0,"gen_end":673601,"gen_start":673470,"node":246,"role":"declaration","source":0,"src_end":546149,"src_start":545929},{"artifact":0,"gen_end":674338,"gen_start":673601,"node":247,"role":"declaration","source":0,"src_end":546745,"src_start":546151},{"artifact":0,"gen_end":674540,"gen_start":674338,"node":248,"role":"declaration","source":0,"src_end":546981,"src_start":546747},{"artifact":0,"gen_end":674667,"gen_start":674540,"node":249,"role":"declaration","source":0,"src_end":547199,"src_start":546983},{"artifact":0,"gen_end":692365,"gen_start":674667,"node":250,"role":"declaration","source":0,"src_end":560813,"src_start":547201},{"artifact":0,"gen_end":692553,"gen_start":692365,"node":251,"role":"declaration","source":0,"src_end":561035,"src_start":560815},{"artifact":0,"gen_end":693604,"gen_start":692553,"node":252,"role":"declaration","source":0,"src_end":562011,"src_start":561037},{"artifact":0,"gen_end":695652,"gen_start":693604,"node":253,"role":"declaration","source":0,"src_end":563607,"src_start":562013},{"artifact":0,"gen_end":696164,"gen_start":695652,"node":254,"role":"declaration","source":0,"src_end":564088,"src_start":563609},{"artifact":0,"gen_end":696335,"gen_start":696164,"node":255,"role":"declaration","source":0,"src_end":564340,"src_start":564090},{"artifact":0,"gen_end":698274,"gen_start":696335,"node":256,"role":"declaration","source":0,"src_end":565874,"src_start":564342},{"artifact":0,"gen_end":698704,"gen_start":698274,"node":257,"role":"declaration","source":0,"src_end":566291,"src_start":565876},{"artifact":0,"gen_end":699033,"gen_start":698704,"node":258,"role":"declaration","source":0,"src_end":566665,"src_start":566293},{"artifact":0,"gen_end":701791,"gen_start":699033,"node":259,"role":"declaration","source":0,"src_end":568802,"src_start":566667},{"artifact":0,"gen_end":702262,"gen_start":701791,"node":260,"role":"declaration","source":0,"src_end":569256,"src_start":568804},{"artifact":0,"gen_end":702426,"gen_start":702262,"node":261,"role":"declaration","source":0,"src_end":569501,"src_start":569258},{"artifact":0,"gen_end":702655,"gen_start":702426,"node":262,"role":"declaration","source":0,"src_end":569828,"src_start":569503},{"artifact":0,"gen_end":705419,"gen_start":702655,"node":263,"role":"declaration","source":0,"src_end":571971,"src_start":569830},{"artifact":0,"gen_end":705902,"gen_start":705419,"node":264,"role":"declaration","source":0,"src_end":572437,"src_start":571973},{"artifact":0,"gen_end":706079,"gen_start":705902,"node":265,"role":"declaration","source":0,"src_end":572695,"src_start":572439},{"artifact":0,"gen_end":706320,"gen_start":706079,"node":266,"role":"declaration","source":0,"src_end":573034,"src_start":572697},{"artifact":0,"gen_end":710993,"gen_start":706320,"node":267,"role":"declaration","source":0,"src_end":576645,"src_start":573036},{"artifact":0,"gen_end":711652,"gen_start":710993,"node":268,"role":"declaration","source":0,"src_end":577248,"src_start":576647},{"artifact":0,"gen_end":711955,"gen_start":711652,"node":269,"role":"declaration","source":0,"src_end":577599,"src_start":577250},{"artifact":0,"gen_end":712308,"gen_start":711955,"node":270,"role":"declaration","source":0,"src_end":578043,"src_start":577601},{"artifact":0,"gen_end":715270,"gen_start":712308,"node":271,"role":"declaration","source":0,"src_end":580389,"src_start":578045},{"artifact":0,"gen_end":715687,"gen_start":715270,"node":272,"role":"declaration","source":0,"src_end":580795,"src_start":580391},{"artifact":0,"gen_end":715842,"gen_start":715687,"node":273,"role":"declaration","source":0,"src_end":581031,"src_start":580797},{"artifact":0,"gen_end":716156,"gen_start":715842,"node":274,"role":"declaration","source":0,"src_end":581427,"src_start":581033},{"artifact":0,"gen_end":719606,"gen_start":716156,"node":275,"role":"declaration","source":0,"src_end":584119,"src_start":581429},{"artifact":0,"gen_end":719998,"gen_start":719606,"node":276,"role":"declaration","source":0,"src_end":584506,"src_start":584121},{"artifact":0,"gen_end":720309,"gen_start":719998,"node":277,"role":"declaration","source":0,"src_end":584865,"src_start":584508},{"artifact":0,"gen_end":720639,"gen_start":720309,"node":278,"role":"declaration","source":0,"src_end":585264,"src_start":584867},{"artifact":0,"gen_end":724076,"gen_start":720639,"node":279,"role":"declaration","source":0,"src_end":587943,"src_start":585266},{"artifact":0,"gen_end":724529,"gen_start":724076,"node":280,"role":"declaration","source":0,"src_end":588385,"src_start":587945},{"artifact":0,"gen_end":724901,"gen_start":724529,"node":281,"role":"declaration","source":0,"src_end":588799,"src_start":588387},{"artifact":0,"gen_end":725247,"gen_start":724901,"node":282,"role":"declaration","source":0,"src_end":589214,"src_start":588801},{"artifact":0,"gen_end":729189,"gen_start":725247,"node":283,"role":"declaration","source":0,"src_end":592302,"src_start":589216},{"artifact":0,"gen_end":729646,"gen_start":729189,"node":284,"role":"declaration","source":0,"src_end":592748,"src_start":592304},{"artifact":0,"gen_end":730022,"gen_start":729646,"node":285,"role":"declaration","source":0,"src_end":593166,"src_start":592750},{"artifact":0,"gen_end":730377,"gen_start":730022,"node":286,"role":"declaration","source":0,"src_end":593590,"src_start":593168},{"artifact":0,"gen_end":733814,"gen_start":730377,"node":287,"role":"declaration","source":0,"src_end":596269,"src_start":593592},{"artifact":0,"gen_end":734287,"gen_start":733814,"node":288,"role":"declaration","source":0,"src_end":596725,"src_start":596271},{"artifact":0,"gen_end":734679,"gen_start":734287,"node":289,"role":"declaration","source":0,"src_end":597153,"src_start":596727},{"artifact":0,"gen_end":735002,"gen_start":734679,"node":290,"role":"declaration","source":0,"src_end":597545,"src_start":597155},{"artifact":0,"gen_end":739355,"gen_start":735002,"node":291,"role":"declaration","source":0,"src_end":600948,"src_start":597547},{"artifact":0,"gen_end":740054,"gen_start":739355,"node":292,"role":"declaration","source":0,"src_end":601582,"src_start":600950},{"artifact":0,"gen_end":740672,"gen_start":740054,"node":293,"role":"declaration","source":0,"src_end":602188,"src_start":601584},{"artifact":0,"gen_end":741081,"gen_start":740672,"node":294,"role":"declaration","source":0,"src_end":602645,"src_start":602190},{"artifact":0,"gen_end":744557,"gen_start":741081,"node":295,"role":"declaration","source":0,"src_end":605363,"src_start":602647},{"artifact":0,"gen_end":745006,"gen_start":744557,"node":296,"role":"declaration","source":0,"src_end":605801,"src_start":605365},{"artifact":0,"gen_end":745374,"gen_start":745006,"node":297,"role":"declaration","source":0,"src_end":606211,"src_start":605803},{"artifact":0,"gen_end":745719,"gen_start":745374,"node":298,"role":"declaration","source":0,"src_end":606625,"src_start":606213},{"artifact":0,"gen_end":750394,"gen_start":745719,"node":299,"role":"declaration","source":0,"src_end":610238,"src_start":606627},{"artifact":0,"gen_end":751057,"gen_start":750394,"node":300,"role":"declaration","source":0,"src_end":610845,"src_start":610240},{"artifact":0,"gen_end":751318,"gen_start":751057,"node":301,"role":"declaration","source":0,"src_end":611160,"src_start":610847},{"artifact":0,"gen_end":751677,"gen_start":751318,"node":302,"role":"declaration","source":0,"src_end":611610,"src_start":611162},{"artifact":0,"gen_end":754613,"gen_start":751677,"node":303,"role":"declaration","source":0,"src_end":613902,"src_start":611612},{"artifact":0,"gen_end":755080,"gen_start":754613,"node":304,"role":"declaration","source":0,"src_end":614352,"src_start":613904},{"artifact":0,"gen_end":755374,"gen_start":755080,"node":305,"role":"declaration","source":0,"src_end":614694,"src_start":614354},{"artifact":0,"gen_end":755691,"gen_start":755374,"node":306,"role":"declaration","source":0,"src_end":615080,"src_start":614696},{"artifact":0,"gen_end":758633,"gen_start":755691,"node":307,"role":"declaration","source":0,"src_end":617378,"src_start":615082},{"artifact":0,"gen_end":759112,"gen_start":758633,"node":308,"role":"declaration","source":0,"src_end":617840,"src_start":617380},{"artifact":0,"gen_end":759464,"gen_start":759112,"node":309,"role":"declaration","source":0,"src_end":618234,"src_start":617842},{"artifact":0,"gen_end":759793,"gen_start":759464,"node":310,"role":"declaration","source":0,"src_end":618632,"src_start":618236},{"artifact":0,"gen_end":764434,"gen_start":759793,"node":311,"role":"declaration","source":0,"src_end":622247,"src_start":618634},{"artifact":0,"gen_end":765083,"gen_start":764434,"node":312,"role":"declaration","source":0,"src_end":622840,"src_start":622249},{"artifact":0,"gen_end":765514,"gen_start":765083,"node":313,"role":"declaration","source":0,"src_end":623301,"src_start":622842},{"artifact":0,"gen_end":765852,"gen_start":765514,"node":314,"role":"declaration","source":0,"src_end":623730,"src_start":623303},{"artifact":0,"gen_end":774593,"gen_start":765852,"node":315,"role":"declaration","source":0,"src_end":630646,"src_start":623732},{"artifact":0,"gen_end":774789,"gen_start":774593,"node":316,"role":"declaration","source":0,"src_end":630876,"src_start":630648},{"artifact":0,"gen_end":776268,"gen_start":774789,"node":317,"role":"declaration","source":0,"src_end":632082,"src_start":630878},{"artifact":0,"gen_end":776512,"gen_start":776268,"node":318,"role":"declaration","source":0,"src_end":632354,"src_start":632084},{"artifact":0,"gen_end":776825,"gen_start":776512,"node":319,"role":"declaration","source":0,"src_end":632730,"src_start":632356},{"artifact":0,"gen_end":778267,"gen_start":776825,"node":320,"role":"declaration","source":0,"src_end":633854,"src_start":632732},{"artifact":0,"gen_end":778497,"gen_start":778267,"node":321,"role":"declaration","source":0,"src_end":634112,"src_start":633856},{"artifact":0,"gen_end":778647,"gen_start":778497,"node":322,"role":"declaration","source":0,"src_end":634343,"src_start":634114},{"artifact":0,"gen_end":780098,"gen_start":778647,"node":323,"role":"declaration","source":0,"src_end":635476,"src_start":634345},{"artifact":0,"gen_end":780344,"gen_start":780098,"node":324,"role":"declaration","source":0,"src_end":635750,"src_start":635478},{"artifact":0,"gen_end":780466,"gen_start":780344,"node":325,"role":"declaration","source":0,"src_end":635965,"src_start":635752},{"artifact":0,"gen_end":786019,"gen_start":780466,"node":326,"role":"declaration","source":0,"src_end":640246,"src_start":635967},{"artifact":0,"gen_end":786261,"gen_start":786019,"node":327,"role":"declaration","source":0,"src_end":640516,"src_start":640248},{"artifact":0,"gen_end":786700,"gen_start":786261,"node":328,"role":"declaration","source":0,"src_end":640982,"src_start":640518},{"artifact":0,"gen_end":793439,"gen_start":786700,"node":329,"role":"declaration","source":0,"src_end":646140,"src_start":640984},{"artifact":0,"gen_end":793720,"gen_start":793439,"node":330,"role":"declaration","source":0,"src_end":646445,"src_start":646142},{"artifact":0,"gen_end":793995,"gen_start":793720,"node":331,"role":"declaration","source":0,"src_end":646779,"src_start":646447},{"artifact":0,"gen_end":802125,"gen_start":793995,"node":332,"role":"declaration","source":0,"src_end":653341,"src_start":646781},{"artifact":0,"gen_end":802363,"gen_start":802125,"node":333,"role":"declaration","source":0,"src_end":653607,"src_start":653343},{"artifact":0,"gen_end":802763,"gen_start":802363,"node":334,"role":"declaration","source":0,"src_end":654038,"src_start":653609},{"artifact":0,"gen_end":802797,"gen_start":802763,"node":0,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":335,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":1,"gen_end":4662,"gen_start":134,"node":336,"role":"declaration","source":0,"src_end":3550,"src_start":210},{"artifact":1,"gen_end":5047,"gen_start":4662,"node":337,"role":"declaration","source":0,"src_end":3782,"src_start":3552},{"artifact":1,"gen_end":5362,"gen_start":5047,"node":338,"role":"declaration","source":0,"src_end":4028,"src_start":3784},{"artifact":1,"gen_end":11423,"gen_start":5362,"node":339,"role":"declaration","source":0,"src_end":8546,"src_start":4030},{"artifact":1,"gen_end":11860,"gen_start":11423,"node":340,"role":"declaration","source":0,"src_end":8824,"src_start":8548},{"artifact":1,"gen_end":12536,"gen_start":11860,"node":341,"role":"declaration","source":0,"src_end":9359,"src_start":8826},{"artifact":1,"gen_end":23711,"gen_start":12536,"node":342,"role":"declaration","source":0,"src_end":17744,"src_start":9361},{"artifact":1,"gen_end":24243,"gen_start":23711,"node":343,"role":"declaration","source":0,"src_end":18105,"src_start":17746},{"artifact":1,"gen_end":25244,"gen_start":24243,"node":344,"role":"declaration","source":0,"src_end":18893,"src_start":18107},{"artifact":1,"gen_end":28814,"gen_start":25244,"node":345,"role":"declaration","source":0,"src_end":21516,"src_start":18895},{"artifact":1,"gen_end":29290,"gen_start":28814,"node":346,"role":"declaration","source":0,"src_end":21827,"src_start":21518},{"artifact":1,"gen_end":29894,"gen_start":29290,"node":347,"role":"declaration","source":0,"src_end":22311,"src_start":21829},{"artifact":1,"gen_end":31441,"gen_start":29894,"node":348,"role":"declaration","source":0,"src_end":23401,"src_start":22313},{"artifact":1,"gen_end":32185,"gen_start":31441,"node":349,"role":"declaration","source":0,"src_end":23910,"src_start":23403},{"artifact":1,"gen_end":32492,"gen_start":32185,"node":350,"role":"declaration","source":0,"src_end":24148,"src_start":23912},{"artifact":1,"gen_end":35867,"gen_start":32492,"node":351,"role":"declaration","source":0,"src_end":26592,"src_start":24150},{"artifact":1,"gen_end":36248,"gen_start":35867,"node":352,"role":"declaration","source":0,"src_end":26820,"src_start":26594},{"artifact":1,"gen_end":42499,"gen_start":36248,"node":353,"role":"declaration","source":0,"src_end":31444,"src_start":26822},{"artifact":1,"gen_end":42876,"gen_start":42499,"node":354,"role":"declaration","source":0,"src_end":31668,"src_start":31446},{"artifact":1,"gen_end":46094,"gen_start":42876,"node":355,"role":"declaration","source":0,"src_end":34045,"src_start":31670},{"artifact":1,"gen_end":46473,"gen_start":46094,"node":356,"role":"declaration","source":0,"src_end":34271,"src_start":34047},{"artifact":1,"gen_end":47084,"gen_start":46473,"node":357,"role":"declaration","source":0,"src_end":34728,"src_start":34273},{"artifact":1,"gen_end":54281,"gen_start":47084,"node":358,"role":"declaration","source":0,"src_end":40112,"src_start":34730},{"artifact":1,"gen_end":54664,"gen_start":54281,"node":359,"role":"declaration","source":0,"src_end":40342,"src_start":40114},{"artifact":1,"gen_end":55764,"gen_start":54664,"node":360,"role":"declaration","source":0,"src_end":41184,"src_start":40344},{"artifact":1,"gen_end":58237,"gen_start":55764,"node":361,"role":"declaration","source":0,"src_end":43042,"src_start":41186},{"artifact":1,"gen_end":58765,"gen_start":58237,"node":362,"role":"declaration","source":0,"src_end":43399,"src_start":43044},{"artifact":1,"gen_end":59085,"gen_start":58765,"node":363,"role":"declaration","source":0,"src_end":43650,"src_start":43401},{"artifact":1,"gen_end":62888,"gen_start":59085,"node":364,"role":"declaration","source":0,"src_end":46530,"src_start":43652},{"artifact":1,"gen_end":63376,"gen_start":62888,"node":365,"role":"declaration","source":0,"src_end":46853,"src_start":46532},{"artifact":1,"gen_end":63778,"gen_start":63376,"node":366,"role":"declaration","source":0,"src_end":47168,"src_start":46855},{"artifact":1,"gen_end":65567,"gen_start":63778,"node":367,"role":"declaration","source":0,"src_end":48492,"src_start":47170},{"artifact":1,"gen_end":66045,"gen_start":65567,"node":368,"role":"declaration","source":0,"src_end":48805,"src_start":48494},{"artifact":1,"gen_end":66361,"gen_start":66045,"node":369,"role":"declaration","source":0,"src_end":49052,"src_start":48807},{"artifact":1,"gen_end":69185,"gen_start":66361,"node":370,"role":"declaration","source":0,"src_end":51097,"src_start":49054},{"artifact":1,"gen_end":69622,"gen_start":69185,"node":371,"role":"declaration","source":0,"src_end":51375,"src_start":51099},{"artifact":1,"gen_end":69942,"gen_start":69622,"node":372,"role":"declaration","source":0,"src_end":51626,"src_start":51377},{"artifact":1,"gen_end":72656,"gen_start":69942,"node":373,"role":"declaration","source":0,"src_end":53608,"src_start":51628},{"artifact":1,"gen_end":73097,"gen_start":72656,"node":374,"role":"declaration","source":0,"src_end":53890,"src_start":53610},{"artifact":1,"gen_end":73420,"gen_start":73097,"node":375,"role":"declaration","source":0,"src_end":54144,"src_start":53892},{"artifact":1,"gen_end":74803,"gen_start":73420,"node":376,"role":"declaration","source":0,"src_end":55131,"src_start":54146},{"artifact":1,"gen_end":75232,"gen_start":74803,"node":377,"role":"declaration","source":0,"src_end":55401,"src_start":55133},{"artifact":1,"gen_end":75642,"gen_start":75232,"node":378,"role":"declaration","source":0,"src_end":55713,"src_start":55403},{"artifact":1,"gen_end":78829,"gen_start":75642,"node":379,"role":"declaration","source":0,"src_end":58081,"src_start":55715},{"artifact":1,"gen_end":79481,"gen_start":78829,"node":380,"role":"declaration","source":0,"src_end":58529,"src_start":58083},{"artifact":1,"gen_end":79972,"gen_start":79481,"node":381,"role":"declaration","source":0,"src_end":58912,"src_start":58531},{"artifact":1,"gen_end":84554,"gen_start":79972,"node":382,"role":"declaration","source":0,"src_end":62449,"src_start":58914},{"artifact":1,"gen_end":84927,"gen_start":84554,"node":383,"role":"declaration","source":0,"src_end":62669,"src_start":62451},{"artifact":1,"gen_end":85873,"gen_start":84927,"node":384,"role":"declaration","source":0,"src_end":63451,"src_start":62671},{"artifact":1,"gen_end":96993,"gen_start":85873,"node":385,"role":"declaration","source":0,"src_end":71974,"src_start":63453},{"artifact":1,"gen_end":97366,"gen_start":96993,"node":386,"role":"declaration","source":0,"src_end":72194,"src_start":71976},{"artifact":1,"gen_end":98305,"gen_start":97366,"node":387,"role":"declaration","source":0,"src_end":72834,"src_start":72196},{"artifact":1,"gen_end":98694,"gen_start":98305,"node":388,"role":"declaration","source":0,"src_end":73070,"src_start":72836},{"artifact":1,"gen_end":99659,"gen_start":98694,"node":389,"role":"declaration","source":0,"src_end":73736,"src_start":73072},{"artifact":1,"gen_end":100056,"gen_start":99659,"node":390,"role":"declaration","source":0,"src_end":73980,"src_start":73738},{"artifact":1,"gen_end":105663,"gen_start":100056,"node":391,"role":"declaration","source":0,"src_end":78216,"src_start":73982},{"artifact":1,"gen_end":106038,"gen_start":105663,"node":392,"role":"declaration","source":0,"src_end":78438,"src_start":78218},{"artifact":1,"gen_end":106741,"gen_start":106038,"node":393,"role":"declaration","source":0,"src_end":79009,"src_start":78440},{"artifact":1,"gen_end":108666,"gen_start":106741,"node":394,"role":"declaration","source":0,"src_end":80400,"src_start":79011},{"artifact":1,"gen_end":109115,"gen_start":108666,"node":395,"role":"declaration","source":0,"src_end":80690,"src_start":80402},{"artifact":1,"gen_end":109451,"gen_start":109115,"node":396,"role":"declaration","source":0,"src_end":80957,"src_start":80692},{"artifact":1,"gen_end":117105,"gen_start":109451,"node":397,"role":"declaration","source":0,"src_end":86862,"src_start":80959},{"artifact":1,"gen_end":117494,"gen_start":117105,"node":398,"role":"declaration","source":0,"src_end":87098,"src_start":86864},{"artifact":1,"gen_end":118581,"gen_start":117494,"node":399,"role":"declaration","source":0,"src_end":87978,"src_start":87100},{"artifact":1,"gen_end":126205,"gen_start":118581,"node":400,"role":"declaration","source":0,"src_end":93861,"src_start":87980},{"artifact":1,"gen_end":126598,"gen_start":126205,"node":401,"role":"declaration","source":0,"src_end":94101,"src_start":93863},{"artifact":1,"gen_end":127598,"gen_start":126598,"node":402,"role":"declaration","source":0,"src_end":94912,"src_start":94103},{"artifact":1,"gen_end":140962,"gen_start":127598,"node":403,"role":"declaration","source":0,"src_end":105303,"src_start":94914},{"artifact":1,"gen_end":141357,"gen_start":140962,"node":404,"role":"declaration","source":0,"src_end":105545,"src_start":105305},{"artifact":1,"gen_end":142958,"gen_start":141357,"node":405,"role":"declaration","source":0,"src_end":106810,"src_start":105547},{"artifact":1,"gen_end":151261,"gen_start":142958,"node":406,"role":"declaration","source":0,"src_end":113236,"src_start":106812},{"artifact":1,"gen_end":151656,"gen_start":151261,"node":407,"role":"declaration","source":0,"src_end":113478,"src_start":113238},{"artifact":1,"gen_end":152667,"gen_start":151656,"node":408,"role":"declaration","source":0,"src_end":114319,"src_start":113480},{"artifact":1,"gen_end":163905,"gen_start":152667,"node":409,"role":"declaration","source":0,"src_end":123112,"src_start":114321},{"artifact":1,"gen_end":164296,"gen_start":163905,"node":410,"role":"declaration","source":0,"src_end":123350,"src_start":123114},{"artifact":1,"gen_end":165596,"gen_start":164296,"node":411,"role":"declaration","source":0,"src_end":124433,"src_start":123352},{"artifact":1,"gen_end":167240,"gen_start":165596,"node":412,"role":"declaration","source":0,"src_end":125634,"src_start":124435},{"artifact":1,"gen_end":167745,"gen_start":167240,"node":413,"role":"declaration","source":0,"src_end":125974,"src_start":125636},{"artifact":1,"gen_end":169389,"gen_start":167745,"node":414,"role":"declaration","source":0,"src_end":127175,"src_start":125976},{"artifact":1,"gen_end":169904,"gen_start":169389,"node":415,"role":"declaration","source":0,"src_end":127525,"src_start":127177},{"artifact":1,"gen_end":171548,"gen_start":169904,"node":416,"role":"declaration","source":0,"src_end":128726,"src_start":127527},{"artifact":1,"gen_end":172081,"gen_start":171548,"node":417,"role":"declaration","source":0,"src_end":129094,"src_start":128728},{"artifact":1,"gen_end":173720,"gen_start":172081,"node":418,"role":"declaration","source":0,"src_end":130290,"src_start":129096},{"artifact":1,"gen_end":174217,"gen_start":173720,"node":419,"role":"declaration","source":0,"src_end":130622,"src_start":130292},{"artifact":1,"gen_end":175861,"gen_start":174217,"node":420,"role":"declaration","source":0,"src_end":131823,"src_start":130624},{"artifact":1,"gen_end":176362,"gen_start":175861,"node":421,"role":"declaration","source":0,"src_end":132159,"src_start":131825},{"artifact":1,"gen_end":178006,"gen_start":176362,"node":422,"role":"declaration","source":0,"src_end":133360,"src_start":132161},{"artifact":1,"gen_end":178512,"gen_start":178006,"node":423,"role":"declaration","source":0,"src_end":133701,"src_start":133362},{"artifact":1,"gen_end":180156,"gen_start":178512,"node":424,"role":"declaration","source":0,"src_end":134902,"src_start":133703},{"artifact":1,"gen_end":180672,"gen_start":180156,"node":425,"role":"declaration","source":0,"src_end":135253,"src_start":134904},{"artifact":1,"gen_end":182311,"gen_start":180672,"node":426,"role":"declaration","source":0,"src_end":136449,"src_start":135255},{"artifact":1,"gen_end":182806,"gen_start":182311,"node":427,"role":"declaration","source":0,"src_end":136779,"src_start":136451},{"artifact":1,"gen_end":205438,"gen_start":182806,"node":428,"role":"declaration","source":0,"src_end":154522,"src_start":136781},{"artifact":1,"gen_end":206001,"gen_start":205438,"node":429,"role":"declaration","source":0,"src_end":154914,"src_start":154524},{"artifact":1,"gen_end":207871,"gen_start":206001,"node":430,"role":"declaration","source":0,"src_end":156415,"src_start":154916},{"artifact":1,"gen_end":230503,"gen_start":207871,"node":431,"role":"declaration","source":0,"src_end":174158,"src_start":156417},{"artifact":1,"gen_end":231076,"gen_start":230503,"node":432,"role":"declaration","source":0,"src_end":174560,"src_start":174160},{"artifact":1,"gen_end":232961,"gen_start":231076,"node":433,"role":"declaration","source":0,"src_end":176076,"src_start":174562},{"artifact":1,"gen_end":255593,"gen_start":232961,"node":434,"role":"declaration","source":0,"src_end":193819,"src_start":176078},{"artifact":1,"gen_end":256184,"gen_start":255593,"node":435,"role":"declaration","source":0,"src_end":194239,"src_start":193821},{"artifact":1,"gen_end":258097,"gen_start":256184,"node":436,"role":"declaration","source":0,"src_end":195783,"src_start":194241},{"artifact":1,"gen_end":280620,"gen_start":258097,"node":437,"role":"declaration","source":0,"src_end":213417,"src_start":195785},{"artifact":1,"gen_end":281173,"gen_start":280620,"node":438,"role":"declaration","source":0,"src_end":213799,"src_start":213419},{"artifact":1,"gen_end":282962,"gen_start":281173,"node":439,"role":"declaration","source":0,"src_end":215229,"src_start":213801},{"artifact":1,"gen_end":303154,"gen_start":282962,"node":440,"role":"declaration","source":0,"src_end":231048,"src_start":215231},{"artifact":1,"gen_end":303714,"gen_start":303154,"node":441,"role":"declaration","source":0,"src_end":231437,"src_start":231050},{"artifact":1,"gen_end":305412,"gen_start":303714,"node":442,"role":"declaration","source":0,"src_end":232802,"src_start":231439},{"artifact":1,"gen_end":325604,"gen_start":305412,"node":443,"role":"declaration","source":0,"src_end":248621,"src_start":232804},{"artifact":1,"gen_end":326169,"gen_start":325604,"node":444,"role":"declaration","source":0,"src_end":249015,"src_start":248623},{"artifact":1,"gen_end":327892,"gen_start":326169,"node":445,"role":"declaration","source":0,"src_end":250405,"src_start":249017},{"artifact":1,"gen_end":348084,"gen_start":327892,"node":446,"role":"declaration","source":0,"src_end":266224,"src_start":250407},{"artifact":1,"gen_end":348659,"gen_start":348084,"node":447,"role":"declaration","source":0,"src_end":266628,"src_start":266226},{"artifact":1,"gen_end":350431,"gen_start":348659,"node":448,"role":"declaration","source":0,"src_end":268067,"src_start":266630},{"artifact":1,"gen_end":370528,"gen_start":350431,"node":449,"role":"declaration","source":0,"src_end":283791,"src_start":268069},{"artifact":1,"gen_end":371080,"gen_start":370528,"node":450,"role":"declaration","source":0,"src_end":284172,"src_start":283793},{"artifact":1,"gen_end":372695,"gen_start":371080,"node":451,"role":"declaration","source":0,"src_end":285464,"src_start":284174},{"artifact":1,"gen_end":390843,"gen_start":372695,"node":452,"role":"declaration","source":0,"src_end":299241,"src_start":285466},{"artifact":1,"gen_end":391230,"gen_start":390843,"node":453,"role":"declaration","source":0,"src_end":299475,"src_start":299243},{"artifact":1,"gen_end":392329,"gen_start":391230,"node":454,"role":"declaration","source":0,"src_end":300339,"src_start":299477},{"artifact":1,"gen_end":419711,"gen_start":392329,"node":455,"role":"declaration","source":0,"src_end":321194,"src_start":300341},{"artifact":1,"gen_end":421121,"gen_start":419711,"node":456,"role":"declaration","source":0,"src_end":322214,"src_start":321196},{"artifact":1,"gen_end":421669,"gen_start":421121,"node":457,"role":"declaration","source":0,"src_end":322648,"src_start":322216},{"artifact":1,"gen_end":422205,"gen_start":421669,"node":458,"role":"declaration","source":0,"src_end":323189,"src_start":322650},{"artifact":1,"gen_end":449593,"gen_start":422205,"node":459,"role":"declaration","source":0,"src_end":344050,"src_start":323191},{"artifact":1,"gen_end":451015,"gen_start":449593,"node":460,"role":"declaration","source":0,"src_end":345082,"src_start":344052},{"artifact":1,"gen_end":451436,"gen_start":451015,"node":461,"role":"declaration","source":0,"src_end":345407,"src_start":345084},{"artifact":1,"gen_end":451983,"gen_start":451436,"node":462,"role":"declaration","source":0,"src_end":345959,"src_start":345409},{"artifact":1,"gen_end":479370,"gen_start":451983,"node":463,"role":"declaration","source":0,"src_end":366819,"src_start":345961},{"artifact":1,"gen_end":480790,"gen_start":479370,"node":464,"role":"declaration","source":0,"src_end":367849,"src_start":366821},{"artifact":1,"gen_end":481256,"gen_start":480790,"node":465,"role":"declaration","source":0,"src_end":368213,"src_start":367851},{"artifact":1,"gen_end":481802,"gen_start":481256,"node":466,"role":"declaration","source":0,"src_end":368764,"src_start":368215},{"artifact":1,"gen_end":486841,"gen_start":481802,"node":467,"role":"declaration","source":0,"src_end":372530,"src_start":368766},{"artifact":1,"gen_end":488253,"gen_start":486841,"node":468,"role":"declaration","source":0,"src_end":373552,"src_start":372532},{"artifact":1,"gen_end":488709,"gen_start":488253,"node":469,"role":"declaration","source":0,"src_end":373906,"src_start":373554},{"artifact":1,"gen_end":489246,"gen_start":488709,"node":470,"role":"declaration","source":0,"src_end":374448,"src_start":373908},{"artifact":1,"gen_end":494291,"gen_start":489246,"node":471,"role":"declaration","source":0,"src_end":378220,"src_start":374450},{"artifact":1,"gen_end":495715,"gen_start":494291,"node":472,"role":"declaration","source":0,"src_end":379254,"src_start":378222},{"artifact":1,"gen_end":496092,"gen_start":495715,"node":473,"role":"declaration","source":0,"src_end":379541,"src_start":379256},{"artifact":1,"gen_end":496642,"gen_start":496092,"node":474,"role":"declaration","source":0,"src_end":380096,"src_start":379543},{"artifact":1,"gen_end":523330,"gen_start":496642,"node":475,"role":"declaration","source":0,"src_end":400342,"src_start":380098},{"artifact":1,"gen_end":524698,"gen_start":523330,"node":476,"role":"declaration","source":0,"src_end":401326,"src_start":400344},{"artifact":1,"gen_end":525290,"gen_start":524698,"node":477,"role":"declaration","source":0,"src_end":401796,"src_start":401328},{"artifact":1,"gen_end":525927,"gen_start":525290,"node":478,"role":"declaration","source":0,"src_end":402462,"src_start":401798},{"artifact":1,"gen_end":552620,"gen_start":525927,"node":479,"role":"declaration","source":0,"src_end":422713,"src_start":402464},{"artifact":1,"gen_end":553777,"gen_start":552620,"node":480,"role":"declaration","source":0,"src_end":423537,"src_start":422715},{"artifact":1,"gen_end":554106,"gen_start":553777,"node":481,"role":"declaration","source":0,"src_end":423799,"src_start":423539},{"artifact":1,"gen_end":554741,"gen_start":554106,"node":482,"role":"declaration","source":0,"src_end":424408,"src_start":423801},{"artifact":1,"gen_end":564291,"gen_start":554741,"node":483,"role":"declaration","source":0,"src_end":431829,"src_start":424410},{"artifact":1,"gen_end":564676,"gen_start":564291,"node":484,"role":"declaration","source":0,"src_end":432061,"src_start":431831},{"artifact":1,"gen_end":565768,"gen_start":564676,"node":485,"role":"declaration","source":0,"src_end":432985,"src_start":432063},{"artifact":1,"gen_end":566755,"gen_start":565768,"node":486,"role":"declaration","source":0,"src_end":433667,"src_start":432987},{"artifact":1,"gen_end":567142,"gen_start":566755,"node":487,"role":"declaration","source":0,"src_end":433901,"src_start":433669},{"artifact":1,"gen_end":567417,"gen_start":567142,"node":488,"role":"declaration","source":0,"src_end":434117,"src_start":433903},{"artifact":1,"gen_end":568275,"gen_start":567417,"node":489,"role":"declaration","source":0,"src_end":434692,"src_start":434119},{"artifact":1,"gen_end":568662,"gen_start":568275,"node":490,"role":"declaration","source":0,"src_end":434926,"src_start":434694},{"artifact":1,"gen_end":568937,"gen_start":568662,"node":491,"role":"declaration","source":0,"src_end":435142,"src_start":434928},{"artifact":1,"gen_end":570058,"gen_start":568937,"node":492,"role":"declaration","source":0,"src_end":435936,"src_start":435144},{"artifact":1,"gen_end":570447,"gen_start":570058,"node":493,"role":"declaration","source":0,"src_end":436172,"src_start":435938},{"artifact":1,"gen_end":570724,"gen_start":570447,"node":494,"role":"declaration","source":0,"src_end":436390,"src_start":436174},{"artifact":1,"gen_end":571712,"gen_start":570724,"node":495,"role":"declaration","source":0,"src_end":437073,"src_start":436392},{"artifact":1,"gen_end":572099,"gen_start":571712,"node":496,"role":"declaration","source":0,"src_end":437307,"src_start":437075},{"artifact":1,"gen_end":572374,"gen_start":572099,"node":497,"role":"declaration","source":0,"src_end":437523,"src_start":437309},{"artifact":1,"gen_end":575115,"gen_start":572374,"node":498,"role":"declaration","source":0,"src_end":439549,"src_start":437525},{"artifact":1,"gen_end":575535,"gen_start":575115,"node":499,"role":"declaration","source":0,"src_end":439810,"src_start":439551},{"artifact":1,"gen_end":575839,"gen_start":575535,"node":500,"role":"declaration","source":0,"src_end":440045,"src_start":439812},{"artifact":1,"gen_end":576219,"gen_start":575839,"node":501,"role":"declaration","source":0,"src_end":440336,"src_start":440047},{"artifact":1,"gen_end":581330,"gen_start":576219,"node":502,"role":"declaration","source":0,"src_end":444150,"src_start":440338},{"artifact":1,"gen_end":581761,"gen_start":581330,"node":503,"role":"declaration","source":0,"src_end":444422,"src_start":444152},{"artifact":1,"gen_end":582161,"gen_start":581761,"node":504,"role":"declaration","source":0,"src_end":444735,"src_start":444424},{"artifact":1,"gen_end":582891,"gen_start":582161,"node":505,"role":"declaration","source":0,"src_end":445365,"src_start":444737},{"artifact":1,"gen_end":588009,"gen_start":582891,"node":506,"role":"declaration","source":0,"src_end":449186,"src_start":445367},{"artifact":1,"gen_end":588453,"gen_start":588009,"node":507,"role":"declaration","source":0,"src_end":449471,"src_start":449188},{"artifact":1,"gen_end":588867,"gen_start":588453,"node":508,"role":"declaration","source":0,"src_end":449798,"src_start":449473},{"artifact":1,"gen_end":589608,"gen_start":588867,"node":509,"role":"declaration","source":0,"src_end":450439,"src_start":449800},{"artifact":1,"gen_end":590610,"gen_start":589608,"node":510,"role":"declaration","source":0,"src_end":451140,"src_start":450441},{"artifact":1,"gen_end":593051,"gen_start":590610,"node":511,"role":"declaration","source":0,"src_end":453134,"src_start":451142},{"artifact":1,"gen_end":595283,"gen_start":593051,"node":512,"role":"declaration","source":0,"src_end":455036,"src_start":453136},{"artifact":1,"gen_end":598645,"gen_start":595283,"node":513,"role":"declaration","source":0,"src_end":457573,"src_start":455038},{"artifact":1,"gen_end":599273,"gen_start":598645,"node":514,"role":"declaration","source":0,"src_end":457997,"src_start":457575},{"artifact":1,"gen_end":599579,"gen_start":599273,"node":515,"role":"declaration","source":0,"src_end":458234,"src_start":457999},{"artifact":1,"gen_end":600104,"gen_start":599579,"node":516,"role":"declaration","source":0,"src_end":458637,"src_start":458236},{"artifact":1,"gen_end":606701,"gen_start":600104,"node":517,"role":"declaration","source":0,"src_end":463681,"src_start":458639},{"artifact":1,"gen_end":607300,"gen_start":606701,"node":518,"role":"declaration","source":0,"src_end":464082,"src_start":463683},{"artifact":1,"gen_end":608455,"gen_start":607300,"node":519,"role":"declaration","source":0,"src_end":464988,"src_start":464084},{"artifact":1,"gen_end":615308,"gen_start":608455,"node":520,"role":"declaration","source":0,"src_end":470464,"src_start":464990},{"artifact":1,"gen_end":615683,"gen_start":615308,"node":521,"role":"declaration","source":0,"src_end":470686,"src_start":470466},{"artifact":1,"gen_end":617785,"gen_start":615683,"node":522,"role":"declaration","source":0,"src_end":472433,"src_start":470688},{"artifact":1,"gen_end":622495,"gen_start":617785,"node":523,"role":"declaration","source":0,"src_end":475937,"src_start":472435},{"artifact":1,"gen_end":623283,"gen_start":622495,"node":524,"role":"declaration","source":0,"src_end":476491,"src_start":475939},{"artifact":1,"gen_end":623597,"gen_start":623283,"node":525,"role":"declaration","source":0,"src_end":476736,"src_start":476493},{"artifact":1,"gen_end":624003,"gen_start":623597,"node":526,"role":"declaration","source":0,"src_end":477112,"src_start":476738},{"artifact":1,"gen_end":627555,"gen_start":624003,"node":527,"role":"declaration","source":0,"src_end":479803,"src_start":477114},{"artifact":1,"gen_end":628289,"gen_start":627555,"node":528,"role":"declaration","source":0,"src_end":480309,"src_start":479805},{"artifact":1,"gen_end":628593,"gen_start":628289,"node":529,"role":"declaration","source":0,"src_end":480544,"src_start":480311},{"artifact":1,"gen_end":629095,"gen_start":628593,"node":530,"role":"declaration","source":0,"src_end":481002,"src_start":480546},{"artifact":1,"gen_end":634882,"gen_start":629095,"node":531,"role":"declaration","source":0,"src_end":485403,"src_start":481004},{"artifact":1,"gen_end":635717,"gen_start":634882,"node":532,"role":"declaration","source":0,"src_end":485998,"src_start":485405},{"artifact":1,"gen_end":636471,"gen_start":635717,"node":533,"role":"declaration","source":0,"src_end":486590,"src_start":486000},{"artifact":1,"gen_end":637002,"gen_start":636471,"node":534,"role":"declaration","source":0,"src_end":487052,"src_start":486592},{"artifact":1,"gen_end":642793,"gen_start":637002,"node":535,"role":"declaration","source":0,"src_end":491457,"src_start":487054},{"artifact":1,"gen_end":643636,"gen_start":642793,"node":536,"role":"declaration","source":0,"src_end":492060,"src_start":491459},{"artifact":1,"gen_end":644398,"gen_start":643636,"node":537,"role":"declaration","source":0,"src_end":492660,"src_start":492062},{"artifact":1,"gen_end":644937,"gen_start":644398,"node":538,"role":"declaration","source":0,"src_end":493130,"src_start":492662},{"artifact":1,"gen_end":650731,"gen_start":644937,"node":539,"role":"declaration","source":0,"src_end":497538,"src_start":493132},{"artifact":1,"gen_end":651580,"gen_start":650731,"node":540,"role":"declaration","source":0,"src_end":498147,"src_start":497540},{"artifact":1,"gen_end":652214,"gen_start":651580,"node":541,"role":"declaration","source":0,"src_end":498643,"src_start":498149},{"artifact":1,"gen_end":652759,"gen_start":652214,"node":542,"role":"declaration","source":0,"src_end":499119,"src_start":498645},{"artifact":1,"gen_end":655106,"gen_start":652759,"node":543,"role":"declaration","source":0,"src_end":500822,"src_start":499121},{"artifact":1,"gen_end":655840,"gen_start":655106,"node":544,"role":"declaration","source":0,"src_end":501328,"src_start":500824},{"artifact":1,"gen_end":656280,"gen_start":655840,"node":545,"role":"declaration","source":0,"src_end":501666,"src_start":501330},{"artifact":1,"gen_end":656716,"gen_start":656280,"node":546,"role":"declaration","source":0,"src_end":502061,"src_start":501668},{"artifact":1,"gen_end":660211,"gen_start":656716,"node":547,"role":"declaration","source":0,"src_end":504649,"src_start":502063},{"artifact":1,"gen_end":660995,"gen_start":660211,"node":548,"role":"declaration","source":0,"src_end":505199,"src_start":504651},{"artifact":1,"gen_end":661346,"gen_start":660995,"node":549,"role":"declaration","source":0,"src_end":505473,"src_start":505201},{"artifact":1,"gen_end":661896,"gen_start":661346,"node":550,"role":"declaration","source":0,"src_end":505990,"src_start":505475},{"artifact":1,"gen_end":665397,"gen_start":661896,"node":551,"role":"declaration","source":0,"src_end":508584,"src_start":505992},{"artifact":1,"gen_end":666193,"gen_start":665397,"node":552,"role":"declaration","source":0,"src_end":509146,"src_start":508586},{"artifact":1,"gen_end":666508,"gen_start":666193,"node":553,"role":"declaration","source":0,"src_end":509394,"src_start":509148},{"artifact":1,"gen_end":667070,"gen_start":666508,"node":554,"role":"declaration","source":0,"src_end":509923,"src_start":509396},{"artifact":1,"gen_end":670830,"gen_start":667070,"node":555,"role":"declaration","source":0,"src_end":512727,"src_start":509925},{"artifact":1,"gen_end":671614,"gen_start":670830,"node":556,"role":"declaration","source":0,"src_end":513277,"src_start":512729},{"artifact":1,"gen_end":672100,"gen_start":671614,"node":557,"role":"declaration","source":0,"src_end":513649,"src_start":513279},{"artifact":1,"gen_end":672625,"gen_start":672100,"node":558,"role":"declaration","source":0,"src_end":514107,"src_start":513651},{"artifact":1,"gen_end":676391,"gen_start":672625,"node":559,"role":"declaration","source":0,"src_end":516917,"src_start":514109},{"artifact":1,"gen_end":677187,"gen_start":676391,"node":560,"role":"declaration","source":0,"src_end":517479,"src_start":516919},{"artifact":1,"gen_end":677819,"gen_start":677187,"node":561,"role":"declaration","source":0,"src_end":517973,"src_start":517481},{"artifact":1,"gen_end":678356,"gen_start":677819,"node":562,"role":"declaration","source":0,"src_end":518443,"src_start":517975},{"artifact":1,"gen_end":680721,"gen_start":678356,"node":563,"role":"declaration","source":0,"src_end":520164,"src_start":518445},{"artifact":1,"gen_end":681459,"gen_start":680721,"node":564,"role":"declaration","source":0,"src_end":520674,"src_start":520166},{"artifact":1,"gen_end":681913,"gen_start":681459,"node":565,"role":"declaration","source":0,"src_end":521026,"src_start":520676},{"artifact":1,"gen_end":682361,"gen_start":681913,"node":566,"role":"declaration","source":0,"src_end":521433,"src_start":521028},{"artifact":1,"gen_end":696635,"gen_start":682361,"node":567,"role":"declaration","source":0,"src_end":532181,"src_start":521435},{"artifact":1,"gen_end":697423,"gen_start":696635,"node":568,"role":"declaration","source":0,"src_end":532741,"src_start":532183},{"artifact":1,"gen_end":698609,"gen_start":697423,"node":569,"role":"declaration","source":0,"src_end":533667,"src_start":532743},{"artifact":1,"gen_end":708673,"gen_start":698609,"node":570,"role":"declaration","source":0,"src_end":541388,"src_start":533669},{"artifact":1,"gen_end":709058,"gen_start":708673,"node":571,"role":"declaration","source":0,"src_end":541620,"src_start":541390},{"artifact":1,"gen_end":710239,"gen_start":709058,"node":572,"role":"declaration","source":0,"src_end":542588,"src_start":541622},{"artifact":1,"gen_end":711211,"gen_start":710239,"node":573,"role":"declaration","source":0,"src_end":543255,"src_start":542590},{"artifact":1,"gen_end":711598,"gen_start":711211,"node":574,"role":"declaration","source":0,"src_end":543489,"src_start":543257},{"artifact":1,"gen_end":711873,"gen_start":711598,"node":575,"role":"declaration","source":0,"src_end":543705,"src_start":543491},{"artifact":1,"gen_end":712844,"gen_start":711873,"node":576,"role":"declaration","source":0,"src_end":544371,"src_start":543707},{"artifact":1,"gen_end":713231,"gen_start":712844,"node":577,"role":"declaration","source":0,"src_end":544605,"src_start":544373},{"artifact":1,"gen_end":713506,"gen_start":713231,"node":578,"role":"declaration","source":0,"src_end":544821,"src_start":544607},{"artifact":1,"gen_end":714734,"gen_start":713506,"node":579,"role":"declaration","source":0,"src_end":545687,"src_start":544823},{"artifact":1,"gen_end":715127,"gen_start":714734,"node":580,"role":"declaration","source":0,"src_end":545927,"src_start":545689},{"artifact":1,"gen_end":715408,"gen_start":715127,"node":581,"role":"declaration","source":0,"src_end":546149,"src_start":545929},{"artifact":1,"gen_end":716295,"gen_start":715408,"node":582,"role":"declaration","source":0,"src_end":546745,"src_start":546151},{"artifact":1,"gen_end":716684,"gen_start":716295,"node":583,"role":"declaration","source":0,"src_end":546981,"src_start":546747},{"artifact":1,"gen_end":716961,"gen_start":716684,"node":584,"role":"declaration","source":0,"src_end":547199,"src_start":546983},{"artifact":1,"gen_end":734935,"gen_start":716961,"node":585,"role":"declaration","source":0,"src_end":560813,"src_start":547201},{"artifact":1,"gen_end":735310,"gen_start":734935,"node":586,"role":"declaration","source":0,"src_end":561035,"src_start":560815},{"artifact":1,"gen_end":736511,"gen_start":735310,"node":587,"role":"declaration","source":0,"src_end":562011,"src_start":561037},{"artifact":1,"gen_end":738745,"gen_start":736511,"node":588,"role":"declaration","source":0,"src_end":563607,"src_start":562013},{"artifact":1,"gen_end":739444,"gen_start":738745,"node":589,"role":"declaration","source":0,"src_end":564088,"src_start":563609},{"artifact":1,"gen_end":739765,"gen_start":739444,"node":590,"role":"declaration","source":0,"src_end":564340,"src_start":564090},{"artifact":1,"gen_end":741856,"gen_start":739765,"node":591,"role":"declaration","source":0,"src_end":565874,"src_start":564342},{"artifact":1,"gen_end":742473,"gen_start":741856,"node":592,"role":"declaration","source":0,"src_end":566291,"src_start":565876},{"artifact":1,"gen_end":742952,"gen_start":742473,"node":593,"role":"declaration","source":0,"src_end":566665,"src_start":566293},{"artifact":1,"gen_end":745886,"gen_start":742952,"node":594,"role":"declaration","source":0,"src_end":568802,"src_start":566667},{"artifact":1,"gen_end":746544,"gen_start":745886,"node":595,"role":"declaration","source":0,"src_end":569256,"src_start":568804},{"artifact":1,"gen_end":746858,"gen_start":746544,"node":596,"role":"declaration","source":0,"src_end":569501,"src_start":569258},{"artifact":1,"gen_end":747237,"gen_start":746858,"node":597,"role":"declaration","source":0,"src_end":569828,"src_start":569503},{"artifact":1,"gen_end":750177,"gen_start":747237,"node":598,"role":"declaration","source":0,"src_end":571971,"src_start":569830},{"artifact":1,"gen_end":750847,"gen_start":750177,"node":599,"role":"declaration","source":0,"src_end":572437,"src_start":571973},{"artifact":1,"gen_end":751174,"gen_start":750847,"node":600,"role":"declaration","source":0,"src_end":572695,"src_start":572439},{"artifact":1,"gen_end":751565,"gen_start":751174,"node":601,"role":"declaration","source":0,"src_end":573034,"src_start":572697},{"artifact":1,"gen_end":756428,"gen_start":751565,"node":602,"role":"declaration","source":0,"src_end":576645,"src_start":573036},{"artifact":1,"gen_end":757274,"gen_start":756428,"node":603,"role":"declaration","source":0,"src_end":577248,"src_start":576647},{"artifact":1,"gen_end":757727,"gen_start":757274,"node":604,"role":"declaration","source":0,"src_end":577599,"src_start":577250},{"artifact":1,"gen_end":758229,"gen_start":757727,"node":605,"role":"declaration","source":0,"src_end":578043,"src_start":577601},{"artifact":1,"gen_end":761357,"gen_start":758229,"node":606,"role":"declaration","source":0,"src_end":580389,"src_start":578045},{"artifact":1,"gen_end":761961,"gen_start":761357,"node":607,"role":"declaration","source":0,"src_end":580795,"src_start":580391},{"artifact":1,"gen_end":762266,"gen_start":761961,"node":608,"role":"declaration","source":0,"src_end":581031,"src_start":580797},{"artifact":1,"gen_end":762730,"gen_start":762266,"node":609,"role":"declaration","source":0,"src_end":581427,"src_start":581033},{"artifact":1,"gen_end":766356,"gen_start":762730,"node":610,"role":"declaration","source":0,"src_end":584119,"src_start":581429},{"artifact":1,"gen_end":766935,"gen_start":766356,"node":611,"role":"declaration","source":0,"src_end":584506,"src_start":584121},{"artifact":1,"gen_end":767396,"gen_start":766935,"node":612,"role":"declaration","source":0,"src_end":584865,"src_start":584508},{"artifact":1,"gen_end":767875,"gen_start":767396,"node":613,"role":"declaration","source":0,"src_end":585264,"src_start":584867},{"artifact":1,"gen_end":771488,"gen_start":767875,"node":614,"role":"declaration","source":0,"src_end":587943,"src_start":585266},{"artifact":1,"gen_end":772128,"gen_start":771488,"node":615,"role":"declaration","source":0,"src_end":588385,"src_start":587945},{"artifact":1,"gen_end":772650,"gen_start":772128,"node":616,"role":"declaration","source":0,"src_end":588799,"src_start":588387},{"artifact":1,"gen_end":773145,"gen_start":772650,"node":617,"role":"declaration","source":0,"src_end":589214,"src_start":588801},{"artifact":1,"gen_end":777263,"gen_start":773145,"node":618,"role":"declaration","source":0,"src_end":592302,"src_start":589216},{"artifact":1,"gen_end":777907,"gen_start":777263,"node":619,"role":"declaration","source":0,"src_end":592748,"src_start":592304},{"artifact":1,"gen_end":778433,"gen_start":777907,"node":620,"role":"declaration","source":0,"src_end":593166,"src_start":592750},{"artifact":1,"gen_end":778937,"gen_start":778433,"node":621,"role":"declaration","source":0,"src_end":593590,"src_start":593168},{"artifact":1,"gen_end":782550,"gen_start":778937,"node":622,"role":"declaration","source":0,"src_end":596269,"src_start":593592},{"artifact":1,"gen_end":783210,"gen_start":782550,"node":623,"role":"declaration","source":0,"src_end":596725,"src_start":596271},{"artifact":1,"gen_end":783752,"gen_start":783210,"node":624,"role":"declaration","source":0,"src_end":597153,"src_start":596727},{"artifact":1,"gen_end":784224,"gen_start":783752,"node":625,"role":"declaration","source":0,"src_end":597545,"src_start":597155},{"artifact":1,"gen_end":788753,"gen_start":784224,"node":626,"role":"declaration","source":0,"src_end":600948,"src_start":597547},{"artifact":1,"gen_end":789639,"gen_start":788753,"node":627,"role":"declaration","source":0,"src_end":601582,"src_start":600950},{"artifact":1,"gen_end":790407,"gen_start":789639,"node":628,"role":"declaration","source":0,"src_end":602188,"src_start":601584},{"artifact":1,"gen_end":790965,"gen_start":790407,"node":629,"role":"declaration","source":0,"src_end":602645,"src_start":602190},{"artifact":1,"gen_end":794617,"gen_start":790965,"node":630,"role":"declaration","source":0,"src_end":605363,"src_start":602647},{"artifact":1,"gen_end":795259,"gen_start":794617,"node":631,"role":"declaration","source":0,"src_end":605801,"src_start":605365},{"artifact":1,"gen_end":795783,"gen_start":795259,"node":632,"role":"declaration","source":0,"src_end":606211,"src_start":605803},{"artifact":1,"gen_end":796283,"gen_start":795783,"node":633,"role":"declaration","source":0,"src_end":606625,"src_start":606213},{"artifact":1,"gen_end":801148,"gen_start":796283,"node":634,"role":"declaration","source":0,"src_end":610238,"src_start":606627},{"artifact":1,"gen_end":801998,"gen_start":801148,"node":635,"role":"declaration","source":0,"src_end":610845,"src_start":610240},{"artifact":1,"gen_end":802409,"gen_start":801998,"node":636,"role":"declaration","source":0,"src_end":611160,"src_start":610847},{"artifact":1,"gen_end":802917,"gen_start":802409,"node":637,"role":"declaration","source":0,"src_end":611610,"src_start":611162},{"artifact":1,"gen_end":806029,"gen_start":802917,"node":638,"role":"declaration","source":0,"src_end":613902,"src_start":611612},{"artifact":1,"gen_end":806683,"gen_start":806029,"node":639,"role":"declaration","source":0,"src_end":614352,"src_start":613904},{"artifact":1,"gen_end":807127,"gen_start":806683,"node":640,"role":"declaration","source":0,"src_end":614694,"src_start":614354},{"artifact":1,"gen_end":807593,"gen_start":807127,"node":641,"role":"declaration","source":0,"src_end":615080,"src_start":614696},{"artifact":1,"gen_end":810711,"gen_start":807593,"node":642,"role":"declaration","source":0,"src_end":617378,"src_start":615082},{"artifact":1,"gen_end":811377,"gen_start":810711,"node":643,"role":"declaration","source":0,"src_end":617840,"src_start":617380},{"artifact":1,"gen_end":811879,"gen_start":811377,"node":644,"role":"declaration","source":0,"src_end":618234,"src_start":617842},{"artifact":1,"gen_end":812357,"gen_start":811879,"node":645,"role":"declaration","source":0,"src_end":618632,"src_start":618236},{"artifact":1,"gen_end":817188,"gen_start":812357,"node":646,"role":"declaration","source":0,"src_end":622247,"src_start":618634},{"artifact":1,"gen_end":818024,"gen_start":817188,"node":647,"role":"declaration","source":0,"src_end":622840,"src_start":622249},{"artifact":1,"gen_end":818605,"gen_start":818024,"node":648,"role":"declaration","source":0,"src_end":623301,"src_start":622842},{"artifact":1,"gen_end":819092,"gen_start":818605,"node":649,"role":"declaration","source":0,"src_end":623730,"src_start":623303},{"artifact":1,"gen_end":827983,"gen_start":819092,"node":650,"role":"declaration","source":0,"src_end":630646,"src_start":623732},{"artifact":1,"gen_end":828366,"gen_start":827983,"node":651,"role":"declaration","source":0,"src_end":630876,"src_start":630648},{"artifact":1,"gen_end":830219,"gen_start":828366,"node":652,"role":"declaration","source":0,"src_end":632082,"src_start":630878},{"artifact":1,"gen_end":830650,"gen_start":830219,"node":653,"role":"declaration","source":0,"src_end":632354,"src_start":632084},{"artifact":1,"gen_end":831225,"gen_start":830650,"node":654,"role":"declaration","source":0,"src_end":632730,"src_start":632356},{"artifact":1,"gen_end":832829,"gen_start":831225,"node":655,"role":"declaration","source":0,"src_end":633854,"src_start":632732},{"artifact":1,"gen_end":833246,"gen_start":832829,"node":656,"role":"declaration","source":0,"src_end":634112,"src_start":633856},{"artifact":1,"gen_end":833546,"gen_start":833246,"node":657,"role":"declaration","source":0,"src_end":634343,"src_start":634114},{"artifact":1,"gen_end":835159,"gen_start":833546,"node":658,"role":"declaration","source":0,"src_end":635476,"src_start":634345},{"artifact":1,"gen_end":835592,"gen_start":835159,"node":659,"role":"declaration","source":0,"src_end":635750,"src_start":635478},{"artifact":1,"gen_end":835864,"gen_start":835592,"node":660,"role":"declaration","source":0,"src_end":635965,"src_start":635752},{"artifact":1,"gen_end":841611,"gen_start":835864,"node":661,"role":"declaration","source":0,"src_end":640246,"src_start":635967},{"artifact":1,"gen_end":842040,"gen_start":841611,"node":662,"role":"declaration","source":0,"src_end":640516,"src_start":640248},{"artifact":1,"gen_end":842629,"gen_start":842040,"node":663,"role":"declaration","source":0,"src_end":640982,"src_start":640518},{"artifact":1,"gen_end":849600,"gen_start":842629,"node":664,"role":"declaration","source":0,"src_end":646140,"src_start":640984},{"artifact":1,"gen_end":850068,"gen_start":849600,"node":665,"role":"declaration","source":0,"src_end":646445,"src_start":646142},{"artifact":1,"gen_end":850493,"gen_start":850068,"node":666,"role":"declaration","source":0,"src_end":646779,"src_start":646447},{"artifact":1,"gen_end":858781,"gen_start":850493,"node":667,"role":"declaration","source":0,"src_end":653341,"src_start":646781},{"artifact":1,"gen_end":859206,"gen_start":858781,"node":668,"role":"declaration","source":0,"src_end":653607,"src_start":653343},{"artifact":1,"gen_end":859756,"gen_start":859206,"node":669,"role":"declaration","source":0,"src_end":654038,"src_start":653609},{"artifact":1,"gen_end":859771,"gen_start":859756,"node":335,"role":"declaration","source":0,"src_end":654074,"src_start":0}],"module":"TargetFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-latex-module"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"},{"id":348,"kind":"semantic-declaration"},{"id":349,"kind":"semantic-declaration"},{"id":350,"kind":"semantic-declaration"},{"id":351,"kind":"semantic-declaration"},{"id":352,"kind":"semantic-declaration"},{"id":353,"kind":"semantic-declaration"},{"id":354,"kind":"semantic-declaration"},{"id":355,"kind":"semantic-declaration"},{"id":356,"kind":"semantic-declaration"},{"id":357,"kind":"semantic-declaration"},{"id":358,"kind":"semantic-declaration"},{"id":359,"kind":"semantic-declaration"},{"id":360,"kind":"semantic-declaration"},{"id":361,"kind":"semantic-declaration"},{"id":362,"kind":"semantic-declaration"},{"id":363,"kind":"semantic-declaration"},{"id":364,"kind":"semantic-declaration"},{"id":365,"kind":"semantic-declaration"},{"id":366,"kind":"semantic-declaration"},{"id":367,"kind":"semantic-declaration"},{"id":368,"kind":"semantic-declaration"},{"id":369,"kind":"semantic-declaration"},{"id":370,"kind":"semantic-declaration"},{"id":371,"kind":"semantic-declaration"},{"id":372,"kind":"semantic-declaration"},{"id":373,"kind":"semantic-declaration"},{"id":374,"kind":"semantic-declaration"},{"id":375,"kind":"semantic-declaration"},{"id":376,"kind":"semantic-declaration"},{"id":377,"kind":"semantic-declaration"},{"id":378,"kind":"semantic-declaration"},{"id":379,"kind":"semantic-declaration"},{"id":380,"kind":"semantic-declaration"},{"id":381,"kind":"semantic-declaration"},{"id":382,"kind":"semantic-declaration"},{"id":383,"kind":"semantic-declaration"},{"id":384,"kind":"semantic-declaration"},{"id":385,"kind":"semantic-declaration"},{"id":386,"kind":"semantic-declaration"},{"id":387,"kind":"semantic-declaration"},{"id":388,"kind":"semantic-declaration"},{"id":389,"kind":"semantic-declaration"},{"id":390,"kind":"semantic-declaration"},{"id":391,"kind":"semantic-declaration"},{"id":392,"kind":"semantic-declaration"},{"id":393,"kind":"semantic-declaration"},{"id":394,"kind":"semantic-declaration"},{"id":395,"kind":"semantic-declaration"},{"id":396,"kind":"semantic-declaration"},{"id":397,"kind":"semantic-declaration"},{"id":398,"kind":"semantic-declaration"},{"id":399,"kind":"semantic-declaration"},{"id":400,"kind":"semantic-declaration"},{"id":401,"kind":"semantic-declaration"},{"id":402,"kind":"semantic-declaration"},{"id":403,"kind":"semantic-declaration"},{"id":404,"kind":"semantic-declaration"},{"id":405,"kind":"semantic-declaration"},{"id":406,"kind":"semantic-declaration"},{"id":407,"kind":"semantic-declaration"},{"id":408,"kind":"semantic-declaration"},{"id":409,"kind":"semantic-declaration"},{"id":410,"kind":"semantic-declaration"},{"id":411,"kind":"semantic-declaration"},{"id":412,"kind":"semantic-declaration"},{"id":413,"kind":"semantic-declaration"},{"id":414,"kind":"semantic-declaration"},{"id":415,"kind":"semantic-declaration"},{"id":416,"kind":"semantic-declaration"},{"id":417,"kind":"semantic-declaration"},{"id":418,"kind":"semantic-declaration"},{"id":419,"kind":"semantic-declaration"},{"id":420,"kind":"semantic-declaration"},{"id":421,"kind":"semantic-declaration"},{"id":422,"kind":"semantic-declaration"},{"id":423,"kind":"semantic-declaration"},{"id":424,"kind":"semantic-declaration"},{"id":425,"kind":"semantic-declaration"},{"id":426,"kind":"semantic-declaration"},{"id":427,"kind":"semantic-declaration"},{"id":428,"kind":"semantic-declaration"},{"id":429,"kind":"semantic-declaration"},{"id":430,"kind":"semantic-declaration"},{"id":431,"kind":"semantic-declaration"},{"id":432,"kind":"semantic-declaration"},{"id":433,"kind":"semantic-declaration"},{"id":434,"kind":"semantic-declaration"},{"id":435,"kind":"semantic-declaration"},{"id":436,"kind":"semantic-declaration"},{"id":437,"kind":"semantic-declaration"},{"id":438,"kind":"semantic-declaration"},{"id":439,"kind":"semantic-declaration"},{"id":440,"kind":"semantic-declaration"},{"id":441,"kind":"semantic-declaration"},{"id":442,"kind":"semantic-declaration"},{"id":443,"kind":"semantic-declaration"},{"id":444,"kind":"semantic-declaration"},{"id":445,"kind":"semantic-declaration"},{"id":446,"kind":"semantic-declaration"},{"id":447,"kind":"semantic-declaration"},{"id":448,"kind":"semantic-declaration"},{"id":449,"kind":"semantic-declaration"},{"id":450,"kind":"semantic-declaration"},{"id":451,"kind":"semantic-declaration"},{"id":452,"kind":"semantic-declaration"},{"id":453,"kind":"semantic-declaration"},{"id":454,"kind":"semantic-declaration"},{"id":455,"kind":"semantic-declaration"},{"id":456,"kind":"semantic-declaration"},{"id":457,"kind":"semantic-declaration"},{"id":458,"kind":"semantic-declaration"},{"id":459,"kind":"semantic-declaration"},{"id":460,"kind":"semantic-declaration"},{"id":461,"kind":"semantic-declaration"},{"id":462,"kind":"semantic-declaration"},{"id":463,"kind":"semantic-declaration"},{"id":464,"kind":"semantic-declaration"},{"id":465,"kind":"semantic-declaration"},{"id":466,"kind":"semantic-declaration"},{"id":467,"kind":"semantic-declaration"},{"id":468,"kind":"semantic-declaration"},{"id":469,"kind":"semantic-declaration"},{"id":470,"kind":"semantic-declaration"},{"id":471,"kind":"semantic-declaration"},{"id":472,"kind":"semantic-declaration"},{"id":473,"kind":"semantic-declaration"},{"id":474,"kind":"semantic-declaration"},{"id":475,"kind":"semantic-declaration"},{"id":476,"kind":"semantic-declaration"},{"id":477,"kind":"semantic-declaration"},{"id":478,"kind":"semantic-declaration"},{"id":479,"kind":"semantic-declaration"},{"id":480,"kind":"semantic-declaration"},{"id":481,"kind":"semantic-declaration"},{"id":482,"kind":"semantic-declaration"},{"id":483,"kind":"semantic-declaration"},{"id":484,"kind":"semantic-declaration"},{"id":485,"kind":"semantic-declaration"},{"id":486,"kind":"semantic-declaration"},{"id":487,"kind":"semantic-declaration"},{"id":488,"kind":"semantic-declaration"},{"id":489,"kind":"semantic-declaration"},{"id":490,"kind":"semantic-declaration"},{"id":491,"kind":"semantic-declaration"},{"id":492,"kind":"semantic-declaration"},{"id":493,"kind":"semantic-declaration"},{"id":494,"kind":"semantic-declaration"},{"id":495,"kind":"semantic-declaration"},{"id":496,"kind":"semantic-declaration"},{"id":497,"kind":"semantic-declaration"},{"id":498,"kind":"semantic-declaration"},{"id":499,"kind":"semantic-declaration"},{"id":500,"kind":"semantic-declaration"},{"id":501,"kind":"semantic-declaration"},{"id":502,"kind":"semantic-declaration"},{"id":503,"kind":"semantic-declaration"},{"id":504,"kind":"semantic-declaration"},{"id":505,"kind":"semantic-declaration"},{"id":506,"kind":"semantic-declaration"},{"id":507,"kind":"semantic-declaration"},{"id":508,"kind":"semantic-declaration"},{"id":509,"kind":"semantic-declaration"},{"id":510,"kind":"semantic-declaration"},{"id":511,"kind":"semantic-declaration"},{"id":512,"kind":"semantic-declaration"},{"id":513,"kind":"semantic-declaration"},{"id":514,"kind":"semantic-declaration"},{"id":515,"kind":"semantic-declaration"},{"id":516,"kind":"semantic-declaration"},{"id":517,"kind":"semantic-declaration"},{"id":518,"kind":"semantic-declaration"},{"id":519,"kind":"semantic-declaration"},{"id":520,"kind":"semantic-declaration"},{"id":521,"kind":"semantic-declaration"},{"id":522,"kind":"semantic-declaration"},{"id":523,"kind":"semantic-declaration"},{"id":524,"kind":"semantic-declaration"},{"id":525,"kind":"semantic-declaration"},{"id":526,"kind":"semantic-declaration"},{"id":527,"kind":"semantic-declaration"},{"id":528,"kind":"semantic-declaration"},{"id":529,"kind":"semantic-declaration"},{"id":530,"kind":"semantic-declaration"},{"id":531,"kind":"semantic-declaration"},{"id":532,"kind":"semantic-declaration"},{"id":533,"kind":"semantic-declaration"},{"id":534,"kind":"semantic-declaration"},{"id":535,"kind":"semantic-declaration"},{"id":536,"kind":"semantic-declaration"},{"id":537,"kind":"semantic-declaration"},{"id":538,"kind":"semantic-declaration"},{"id":539,"kind":"semantic-declaration"},{"id":540,"kind":"semantic-declaration"},{"id":541,"kind":"semantic-declaration"},{"id":542,"kind":"semantic-declaration"},{"id":543,"kind":"semantic-declaration"},{"id":544,"kind":"semantic-declaration"},{"id":545,"kind":"semantic-declaration"},{"id":546,"kind":"semantic-declaration"},{"id":547,"kind":"semantic-declaration"},{"id":548,"kind":"semantic-declaration"},{"id":549,"kind":"semantic-declaration"},{"id":550,"kind":"semantic-declaration"},{"id":551,"kind":"semantic-declaration"},{"id":552,"kind":"semantic-declaration"},{"id":553,"kind":"semantic-declaration"},{"id":554,"kind":"semantic-declaration"},{"id":555,"kind":"semantic-declaration"},{"id":556,"kind":"semantic-declaration"},{"id":557,"kind":"semantic-declaration"},{"id":558,"kind":"semantic-declaration"},{"id":559,"kind":"semantic-declaration"},{"id":560,"kind":"semantic-declaration"},{"id":561,"kind":"semantic-declaration"},{"id":562,"kind":"semantic-declaration"},{"id":563,"kind":"semantic-declaration"},{"id":564,"kind":"semantic-declaration"},{"id":565,"kind":"semantic-declaration"},{"id":566,"kind":"semantic-declaration"},{"id":567,"kind":"semantic-declaration"},{"id":568,"kind":"semantic-declaration"},{"id":569,"kind":"semantic-declaration"},{"id":570,"kind":"semantic-declaration"},{"id":571,"kind":"semantic-declaration"},{"id":572,"kind":"semantic-declaration"},{"id":573,"kind":"semantic-declaration"},{"id":574,"kind":"semantic-declaration"},{"id":575,"kind":"semantic-declaration"},{"id":576,"kind":"semantic-declaration"},{"id":577,"kind":"semantic-declaration"},{"id":578,"kind":"semantic-declaration"},{"id":579,"kind":"semantic-declaration"},{"id":580,"kind":"semantic-declaration"},{"id":581,"kind":"semantic-declaration"},{"id":582,"kind":"semantic-declaration"},{"id":583,"kind":"semantic-declaration"},{"id":584,"kind":"semantic-declaration"},{"id":585,"kind":"semantic-declaration"},{"id":586,"kind":"semantic-declaration"},{"id":587,"kind":"semantic-declaration"},{"id":588,"kind":"semantic-declaration"},{"id":589,"kind":"semantic-declaration"},{"id":590,"kind":"semantic-declaration"},{"id":591,"kind":"semantic-declaration"},{"id":592,"kind":"semantic-declaration"},{"id":593,"kind":"semantic-declaration"},{"id":594,"kind":"semantic-declaration"},{"id":595,"kind":"semantic-declaration"},{"id":596,"kind":"semantic-declaration"},{"id":597,"kind":"semantic-declaration"},{"id":598,"kind":"semantic-declaration"},{"id":599,"kind":"semantic-declaration"},{"id":600,"kind":"semantic-declaration"},{"id":601,"kind":"semantic-declaration"},{"id":602,"kind":"semantic-declaration"},{"id":603,"kind":"semantic-declaration"},{"id":604,"kind":"semantic-declaration"},{"id":605,"kind":"semantic-declaration"},{"id":606,"kind":"semantic-declaration"},{"id":607,"kind":"semantic-declaration"},{"id":608,"kind":"semantic-declaration"},{"id":609,"kind":"semantic-declaration"},{"id":610,"kind":"semantic-declaration"},{"id":611,"kind":"semantic-declaration"},{"id":612,"kind":"semantic-declaration"},{"id":613,"kind":"semantic-declaration"},{"id":614,"kind":"semantic-declaration"},{"id":615,"kind":"semantic-declaration"},{"id":616,"kind":"semantic-declaration"},{"id":617,"kind":"semantic-declaration"},{"id":618,"kind":"semantic-declaration"},{"id":619,"kind":"semantic-declaration"},{"id":620,"kind":"semantic-declaration"},{"id":621,"kind":"semantic-declaration"},{"id":622,"kind":"semantic-declaration"},{"id":623,"kind":"semantic-declaration"},{"id":624,"kind":"semantic-declaration"},{"id":625,"kind":"semantic-declaration"},{"id":626,"kind":"semantic-declaration"},{"id":627,"kind":"semantic-declaration"},{"id":628,"kind":"semantic-declaration"},{"id":629,"kind":"semantic-declaration"},{"id":630,"kind":"semantic-declaration"},{"id":631,"kind":"semantic-declaration"},{"id":632,"kind":"semantic-declaration"},{"id":633,"kind":"semantic-declaration"},{"id":634,"kind":"semantic-declaration"},{"id":635,"kind":"semantic-declaration"},{"id":636,"kind":"semantic-declaration"},{"id":637,"kind":"semantic-declaration"},{"id":638,"kind":"semantic-declaration"},{"id":639,"kind":"semantic-declaration"},{"id":640,"kind":"semantic-declaration"},{"id":641,"kind":"semantic-declaration"},{"id":642,"kind":"semantic-declaration"},{"id":643,"kind":"semantic-declaration"},{"id":644,"kind":"semantic-declaration"},{"id":645,"kind":"semantic-declaration"},{"id":646,"kind":"semantic-declaration"},{"id":647,"kind":"semantic-declaration"},{"id":648,"kind":"semantic-declaration"},{"id":649,"kind":"semantic-declaration"},{"id":650,"kind":"semantic-declaration"},{"id":651,"kind":"semantic-declaration"},{"id":652,"kind":"semantic-declaration"},{"id":653,"kind":"semantic-declaration"},{"id":654,"kind":"semantic-declaration"},{"id":655,"kind":"semantic-declaration"},{"id":656,"kind":"semantic-declaration"},{"id":657,"kind":"semantic-declaration"},{"id":658,"kind":"semantic-declaration"},{"id":659,"kind":"semantic-declaration"},{"id":660,"kind":"semantic-declaration"},{"id":661,"kind":"semantic-declaration"},{"id":662,"kind":"semantic-declaration"},{"id":663,"kind":"semantic-declaration"},{"id":664,"kind":"semantic-declaration"},{"id":665,"kind":"semantic-declaration"},{"id":666,"kind":"semantic-declaration"},{"id":667,"kind":"semantic-declaration"},{"id":668,"kind":"semantic-declaration"},{"id":669,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/TargetFixtures.lex.tex","sha256":"d746739ea3e78234f7a68280dc068d39b84f4064298a37383a8dc645bc188c27"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetFixtures.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetFixtures.tex"}],"mappings":[{"artifact":0,"gen_end":416,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":0,"gen_end":4776,"gen_start":416,"node":1,"role":"declaration","source":0,"src_end":3550,"src_start":210},{"artifact":0,"gen_end":4974,"gen_start":4776,"node":2,"role":"declaration","source":0,"src_end":3782,"src_start":3552},{"artifact":0,"gen_end":5139,"gen_start":4974,"node":3,"role":"declaration","source":0,"src_end":4028,"src_start":3784},{"artifact":0,"gen_end":10978,"gen_start":5139,"node":4,"role":"declaration","source":0,"src_end":8546,"src_start":4030},{"artifact":0,"gen_end":11228,"gen_start":10978,"node":5,"role":"declaration","source":0,"src_end":8824,"src_start":8548},{"artifact":0,"gen_end":11754,"gen_start":11228,"node":6,"role":"declaration","source":0,"src_end":9359,"src_start":8826},{"artifact":0,"gen_end":22707,"gen_start":11754,"node":7,"role":"declaration","source":0,"src_end":17744,"src_start":9361},{"artifact":0,"gen_end":23052,"gen_start":22707,"node":8,"role":"declaration","source":0,"src_end":18105,"src_start":17746},{"artifact":0,"gen_end":23903,"gen_start":23052,"node":9,"role":"declaration","source":0,"src_end":18893,"src_start":18107},{"artifact":0,"gen_end":27311,"gen_start":23903,"node":10,"role":"declaration","source":0,"src_end":21516,"src_start":18895},{"artifact":0,"gen_end":27600,"gen_start":27311,"node":11,"role":"declaration","source":0,"src_end":21827,"src_start":21518},{"artifact":0,"gen_end":28054,"gen_start":27600,"node":12,"role":"declaration","source":0,"src_end":22311,"src_start":21829},{"artifact":0,"gen_end":29437,"gen_start":28054,"node":13,"role":"declaration","source":0,"src_end":23401,"src_start":22313},{"artifact":0,"gen_end":29994,"gen_start":29437,"node":14,"role":"declaration","source":0,"src_end":23910,"src_start":23403},{"artifact":0,"gen_end":30151,"gen_start":29994,"node":15,"role":"declaration","source":0,"src_end":24148,"src_start":23912},{"artifact":0,"gen_end":33368,"gen_start":30151,"node":16,"role":"declaration","source":0,"src_end":26592,"src_start":24150},{"artifact":0,"gen_end":33562,"gen_start":33368,"node":17,"role":"declaration","source":0,"src_end":26820,"src_start":26594},{"artifact":0,"gen_end":39640,"gen_start":33562,"node":18,"role":"declaration","source":0,"src_end":31444,"src_start":26822},{"artifact":0,"gen_end":39830,"gen_start":39640,"node":19,"role":"declaration","source":0,"src_end":31668,"src_start":31446},{"artifact":0,"gen_end":42895,"gen_start":39830,"node":20,"role":"declaration","source":0,"src_end":34045,"src_start":31670},{"artifact":0,"gen_end":43087,"gen_start":42895,"node":21,"role":"declaration","source":0,"src_end":34271,"src_start":34047},{"artifact":0,"gen_end":43546,"gen_start":43087,"node":22,"role":"declaration","source":0,"src_end":34728,"src_start":34273},{"artifact":0,"gen_end":50575,"gen_start":43546,"node":23,"role":"declaration","source":0,"src_end":40112,"src_start":34730},{"artifact":0,"gen_end":50771,"gen_start":50575,"node":24,"role":"declaration","source":0,"src_end":40342,"src_start":40114},{"artifact":0,"gen_end":51714,"gen_start":50771,"node":25,"role":"declaration","source":0,"src_end":41184,"src_start":40344},{"artifact":0,"gen_end":54033,"gen_start":51714,"node":26,"role":"declaration","source":0,"src_end":43042,"src_start":41186},{"artifact":0,"gen_end":54374,"gen_start":54033,"node":27,"role":"declaration","source":0,"src_end":43399,"src_start":43044},{"artifact":0,"gen_end":54544,"gen_start":54374,"node":28,"role":"declaration","source":0,"src_end":43650,"src_start":43401},{"artifact":0,"gen_end":58191,"gen_start":54544,"node":29,"role":"declaration","source":0,"src_end":46530,"src_start":43652},{"artifact":0,"gen_end":58492,"gen_start":58191,"node":30,"role":"declaration","source":0,"src_end":46853,"src_start":46532},{"artifact":0,"gen_end":58744,"gen_start":58492,"node":31,"role":"declaration","source":0,"src_end":47168,"src_start":46855},{"artifact":0,"gen_end":60381,"gen_start":58744,"node":32,"role":"declaration","source":0,"src_end":48492,"src_start":47170},{"artifact":0,"gen_end":60672,"gen_start":60381,"node":33,"role":"declaration","source":0,"src_end":48805,"src_start":48494},{"artifact":0,"gen_end":60838,"gen_start":60672,"node":34,"role":"declaration","source":0,"src_end":49052,"src_start":48807},{"artifact":0,"gen_end":63484,"gen_start":60838,"node":35,"role":"declaration","source":0,"src_end":51097,"src_start":49054},{"artifact":0,"gen_end":63734,"gen_start":63484,"node":36,"role":"declaration","source":0,"src_end":51375,"src_start":51099},{"artifact":0,"gen_end":63904,"gen_start":63734,"node":37,"role":"declaration","source":0,"src_end":51626,"src_start":51377},{"artifact":0,"gen_end":66452,"gen_start":63904,"node":38,"role":"declaration","source":0,"src_end":53608,"src_start":51628},{"artifact":0,"gen_end":66706,"gen_start":66452,"node":39,"role":"declaration","source":0,"src_end":53890,"src_start":53610},{"artifact":0,"gen_end":66879,"gen_start":66706,"node":40,"role":"declaration","source":0,"src_end":54144,"src_start":53892},{"artifact":0,"gen_end":68110,"gen_start":66879,"node":41,"role":"declaration","source":0,"src_end":55131,"src_start":54146},{"artifact":0,"gen_end":68352,"gen_start":68110,"node":42,"role":"declaration","source":0,"src_end":55401,"src_start":55133},{"artifact":0,"gen_end":68612,"gen_start":68352,"node":43,"role":"declaration","source":0,"src_end":55713,"src_start":55403},{"artifact":0,"gen_end":71633,"gen_start":68612,"node":44,"role":"declaration","source":0,"src_end":58081,"src_start":55715},{"artifact":0,"gen_end":72098,"gen_start":71633,"node":45,"role":"declaration","source":0,"src_end":58529,"src_start":58083},{"artifact":0,"gen_end":72439,"gen_start":72098,"node":46,"role":"declaration","source":0,"src_end":58912,"src_start":58531},{"artifact":0,"gen_end":76869,"gen_start":72439,"node":47,"role":"declaration","source":0,"src_end":62449,"src_start":58914},{"artifact":0,"gen_end":77055,"gen_start":76869,"node":48,"role":"declaration","source":0,"src_end":62669,"src_start":62451},{"artifact":0,"gen_end":77851,"gen_start":77055,"node":49,"role":"declaration","source":0,"src_end":63451,"src_start":62671},{"artifact":0,"gen_end":88821,"gen_start":77851,"node":50,"role":"declaration","source":0,"src_end":71974,"src_start":63453},{"artifact":0,"gen_end":89007,"gen_start":88821,"node":51,"role":"declaration","source":0,"src_end":72194,"src_start":71976},{"artifact":0,"gen_end":89796,"gen_start":89007,"node":52,"role":"declaration","source":0,"src_end":72834,"src_start":72196},{"artifact":0,"gen_end":89998,"gen_start":89796,"node":53,"role":"declaration","source":0,"src_end":73070,"src_start":72836},{"artifact":0,"gen_end":90813,"gen_start":89998,"node":54,"role":"declaration","source":0,"src_end":73736,"src_start":73072},{"artifact":0,"gen_end":91023,"gen_start":90813,"node":55,"role":"declaration","source":0,"src_end":73980,"src_start":73738},{"artifact":0,"gen_end":96468,"gen_start":91023,"node":56,"role":"declaration","source":0,"src_end":78216,"src_start":73982},{"artifact":0,"gen_end":96656,"gen_start":96468,"node":57,"role":"declaration","source":0,"src_end":78438,"src_start":78218},{"artifact":0,"gen_end":97209,"gen_start":96656,"node":58,"role":"declaration","source":0,"src_end":79009,"src_start":78440},{"artifact":0,"gen_end":98982,"gen_start":97209,"node":59,"role":"declaration","source":0,"src_end":80400,"src_start":79011},{"artifact":0,"gen_end":99244,"gen_start":98982,"node":60,"role":"declaration","source":0,"src_end":80690,"src_start":80402},{"artifact":0,"gen_end":99430,"gen_start":99244,"node":61,"role":"declaration","source":0,"src_end":80957,"src_start":80692},{"artifact":0,"gen_end":106934,"gen_start":99430,"node":62,"role":"declaration","source":0,"src_end":86862,"src_start":80959},{"artifact":0,"gen_end":107136,"gen_start":106934,"node":63,"role":"declaration","source":0,"src_end":87098,"src_start":86864},{"artifact":0,"gen_end":108073,"gen_start":107136,"node":64,"role":"declaration","source":0,"src_end":87978,"src_start":87100},{"artifact":0,"gen_end":115547,"gen_start":108073,"node":65,"role":"declaration","source":0,"src_end":93861,"src_start":87980},{"artifact":0,"gen_end":115753,"gen_start":115547,"node":66,"role":"declaration","source":0,"src_end":94101,"src_start":93863},{"artifact":0,"gen_end":116603,"gen_start":115753,"node":67,"role":"declaration","source":0,"src_end":94912,"src_start":94103},{"artifact":0,"gen_end":129817,"gen_start":116603,"node":68,"role":"declaration","source":0,"src_end":105303,"src_start":94914},{"artifact":0,"gen_end":130025,"gen_start":129817,"node":69,"role":"declaration","source":0,"src_end":105545,"src_start":105305},{"artifact":0,"gen_end":131476,"gen_start":130025,"node":70,"role":"declaration","source":0,"src_end":106810,"src_start":105547},{"artifact":0,"gen_end":139629,"gen_start":131476,"node":71,"role":"declaration","source":0,"src_end":113236,"src_start":106812},{"artifact":0,"gen_end":139837,"gen_start":139629,"node":72,"role":"declaration","source":0,"src_end":113478,"src_start":113238},{"artifact":0,"gen_end":140698,"gen_start":139837,"node":73,"role":"declaration","source":0,"src_end":114319,"src_start":113480},{"artifact":0,"gen_end":151786,"gen_start":140698,"node":74,"role":"declaration","source":0,"src_end":123112,"src_start":114321},{"artifact":0,"gen_end":151990,"gen_start":151786,"node":75,"role":"declaration","source":0,"src_end":123350,"src_start":123114},{"artifact":0,"gen_end":153140,"gen_start":151990,"node":76,"role":"declaration","source":0,"src_end":124433,"src_start":123352},{"artifact":0,"gen_end":154634,"gen_start":153140,"node":77,"role":"declaration","source":0,"src_end":125634,"src_start":124435},{"artifact":0,"gen_end":154952,"gen_start":154634,"node":78,"role":"declaration","source":0,"src_end":125974,"src_start":125636},{"artifact":0,"gen_end":156446,"gen_start":154952,"node":79,"role":"declaration","source":0,"src_end":127175,"src_start":125976},{"artifact":0,"gen_end":156774,"gen_start":156446,"node":80,"role":"declaration","source":0,"src_end":127525,"src_start":127177},{"artifact":0,"gen_end":158268,"gen_start":156774,"node":81,"role":"declaration","source":0,"src_end":128726,"src_start":127527},{"artifact":0,"gen_end":158614,"gen_start":158268,"node":82,"role":"declaration","source":0,"src_end":129094,"src_start":128728},{"artifact":0,"gen_end":160103,"gen_start":158614,"node":83,"role":"declaration","source":0,"src_end":130290,"src_start":129096},{"artifact":0,"gen_end":160413,"gen_start":160103,"node":84,"role":"declaration","source":0,"src_end":130622,"src_start":130292},{"artifact":0,"gen_end":161907,"gen_start":160413,"node":85,"role":"declaration","source":0,"src_end":131823,"src_start":130624},{"artifact":0,"gen_end":162221,"gen_start":161907,"node":86,"role":"declaration","source":0,"src_end":132159,"src_start":131825},{"artifact":0,"gen_end":163715,"gen_start":162221,"node":87,"role":"declaration","source":0,"src_end":133360,"src_start":132161},{"artifact":0,"gen_end":164034,"gen_start":163715,"node":88,"role":"declaration","source":0,"src_end":133701,"src_start":133362},{"artifact":0,"gen_end":165528,"gen_start":164034,"node":89,"role":"declaration","source":0,"src_end":134902,"src_start":133703},{"artifact":0,"gen_end":165857,"gen_start":165528,"node":90,"role":"declaration","source":0,"src_end":135253,"src_start":134904},{"artifact":0,"gen_end":167346,"gen_start":165857,"node":91,"role":"declaration","source":0,"src_end":136449,"src_start":135255},{"artifact":0,"gen_end":167654,"gen_start":167346,"node":92,"role":"declaration","source":0,"src_end":136779,"src_start":136451},{"artifact":0,"gen_end":190136,"gen_start":167654,"node":93,"role":"declaration","source":0,"src_end":154522,"src_start":136781},{"artifact":0,"gen_end":190512,"gen_start":190136,"node":94,"role":"declaration","source":0,"src_end":154914,"src_start":154524},{"artifact":0,"gen_end":192232,"gen_start":190512,"node":95,"role":"declaration","source":0,"src_end":156415,"src_start":154916},{"artifact":0,"gen_end":214714,"gen_start":192232,"node":96,"role":"declaration","source":0,"src_end":174158,"src_start":156417},{"artifact":0,"gen_end":215100,"gen_start":214714,"node":97,"role":"declaration","source":0,"src_end":174560,"src_start":174160},{"artifact":0,"gen_end":216835,"gen_start":215100,"node":98,"role":"declaration","source":0,"src_end":176076,"src_start":174562},{"artifact":0,"gen_end":239317,"gen_start":216835,"node":99,"role":"declaration","source":0,"src_end":193819,"src_start":176078},{"artifact":0,"gen_end":239721,"gen_start":239317,"node":100,"role":"declaration","source":0,"src_end":194239,"src_start":193821},{"artifact":0,"gen_end":241484,"gen_start":239721,"node":101,"role":"declaration","source":0,"src_end":195783,"src_start":194241},{"artifact":0,"gen_end":263857,"gen_start":241484,"node":102,"role":"declaration","source":0,"src_end":213417,"src_start":195785},{"artifact":0,"gen_end":264223,"gen_start":263857,"node":103,"role":"declaration","source":0,"src_end":213799,"src_start":213419},{"artifact":0,"gen_end":265862,"gen_start":264223,"node":104,"role":"declaration","source":0,"src_end":215229,"src_start":213801},{"artifact":0,"gen_end":285904,"gen_start":265862,"node":105,"role":"declaration","source":0,"src_end":231048,"src_start":215231},{"artifact":0,"gen_end":286277,"gen_start":285904,"node":106,"role":"declaration","source":0,"src_end":231437,"src_start":231050},{"artifact":0,"gen_end":287825,"gen_start":286277,"node":107,"role":"declaration","source":0,"src_end":232802,"src_start":231439},{"artifact":0,"gen_end":307867,"gen_start":287825,"node":108,"role":"declaration","source":0,"src_end":248621,"src_start":232804},{"artifact":0,"gen_end":308245,"gen_start":307867,"node":109,"role":"declaration","source":0,"src_end":249015,"src_start":248623},{"artifact":0,"gen_end":309818,"gen_start":308245,"node":110,"role":"declaration","source":0,"src_end":250405,"src_start":249017},{"artifact":0,"gen_end":329860,"gen_start":309818,"node":111,"role":"declaration","source":0,"src_end":266224,"src_start":250407},{"artifact":0,"gen_end":330248,"gen_start":329860,"node":112,"role":"declaration","source":0,"src_end":266628,"src_start":266226},{"artifact":0,"gen_end":331870,"gen_start":330248,"node":113,"role":"declaration","source":0,"src_end":268067,"src_start":266630},{"artifact":0,"gen_end":351817,"gen_start":331870,"node":114,"role":"declaration","source":0,"src_end":283791,"src_start":268069},{"artifact":0,"gen_end":352182,"gen_start":351817,"node":115,"role":"declaration","source":0,"src_end":284172,"src_start":283793},{"artifact":0,"gen_end":353647,"gen_start":352182,"node":116,"role":"declaration","source":0,"src_end":285464,"src_start":284174},{"artifact":0,"gen_end":371515,"gen_start":353647,"node":117,"role":"declaration","source":0,"src_end":299241,"src_start":285466},{"artifact":0,"gen_end":371715,"gen_start":371515,"node":118,"role":"declaration","source":0,"src_end":299475,"src_start":299243},{"artifact":0,"gen_end":372664,"gen_start":371715,"node":119,"role":"declaration","source":0,"src_end":300339,"src_start":299477},{"artifact":0,"gen_end":399642,"gen_start":372664,"node":120,"role":"declaration","source":0,"src_end":321194,"src_start":300341},{"artifact":0,"gen_end":400865,"gen_start":399642,"node":121,"role":"declaration","source":0,"src_end":322214,"src_start":321196},{"artifact":0,"gen_end":401263,"gen_start":400865,"node":122,"role":"declaration","source":0,"src_end":322648,"src_start":322216},{"artifact":0,"gen_end":401650,"gen_start":401263,"node":123,"role":"declaration","source":0,"src_end":323189,"src_start":322650},{"artifact":0,"gen_end":428634,"gen_start":401650,"node":124,"role":"declaration","source":0,"src_end":344050,"src_start":323191},{"artifact":0,"gen_end":429869,"gen_start":428634,"node":125,"role":"declaration","source":0,"src_end":345082,"src_start":344052},{"artifact":0,"gen_end":430140,"gen_start":429869,"node":126,"role":"declaration","source":0,"src_end":345407,"src_start":345084},{"artifact":0,"gen_end":430538,"gen_start":430140,"node":127,"role":"declaration","source":0,"src_end":345959,"src_start":345409},{"artifact":0,"gen_end":457521,"gen_start":430538,"node":128,"role":"declaration","source":0,"src_end":366819,"src_start":345961},{"artifact":0,"gen_end":458754,"gen_start":457521,"node":129,"role":"declaration","source":0,"src_end":367849,"src_start":366821},{"artifact":0,"gen_end":459070,"gen_start":458754,"node":130,"role":"declaration","source":0,"src_end":368213,"src_start":367851},{"artifact":0,"gen_end":459467,"gen_start":459070,"node":131,"role":"declaration","source":0,"src_end":368764,"src_start":368215},{"artifact":0,"gen_end":464316,"gen_start":459467,"node":132,"role":"declaration","source":0,"src_end":372530,"src_start":368766},{"artifact":0,"gen_end":465541,"gen_start":464316,"node":133,"role":"declaration","source":0,"src_end":373552,"src_start":372532},{"artifact":0,"gen_end":465847,"gen_start":465541,"node":134,"role":"declaration","source":0,"src_end":373906,"src_start":373554},{"artifact":0,"gen_end":466235,"gen_start":465847,"node":135,"role":"declaration","source":0,"src_end":374448,"src_start":373908},{"artifact":0,"gen_end":471090,"gen_start":466235,"node":136,"role":"declaration","source":0,"src_end":378220,"src_start":374450},{"artifact":0,"gen_end":472327,"gen_start":471090,"node":137,"role":"declaration","source":0,"src_end":379254,"src_start":378222},{"artifact":0,"gen_end":472554,"gen_start":472327,"node":138,"role":"declaration","source":0,"src_end":379541,"src_start":379256},{"artifact":0,"gen_end":472955,"gen_start":472554,"node":139,"role":"declaration","source":0,"src_end":380096,"src_start":379543},{"artifact":0,"gen_end":499241,"gen_start":472955,"node":140,"role":"declaration","source":0,"src_end":400342,"src_start":380098},{"artifact":0,"gen_end":500422,"gen_start":499241,"node":141,"role":"declaration","source":0,"src_end":401326,"src_start":400344},{"artifact":0,"gen_end":500864,"gen_start":500422,"node":142,"role":"declaration","source":0,"src_end":401796,"src_start":401328},{"artifact":0,"gen_end":501351,"gen_start":500864,"node":143,"role":"declaration","source":0,"src_end":402462,"src_start":401798},{"artifact":0,"gen_end":527642,"gen_start":501351,"node":144,"role":"declaration","source":0,"src_end":422713,"src_start":402464},{"artifact":0,"gen_end":528612,"gen_start":527642,"node":145,"role":"declaration","source":0,"src_end":423537,"src_start":422715},{"artifact":0,"gen_end":528791,"gen_start":528612,"node":146,"role":"declaration","source":0,"src_end":423799,"src_start":423539},{"artifact":0,"gen_end":529276,"gen_start":528791,"node":147,"role":"declaration","source":0,"src_end":424408,"src_start":423801},{"artifact":0,"gen_end":538676,"gen_start":529276,"node":148,"role":"declaration","source":0,"src_end":431829,"src_start":424410},{"artifact":0,"gen_end":538874,"gen_start":538676,"node":149,"role":"declaration","source":0,"src_end":432061,"src_start":431831},{"artifact":0,"gen_end":539816,"gen_start":538874,"node":150,"role":"declaration","source":0,"src_end":432985,"src_start":432063},{"artifact":0,"gen_end":540653,"gen_start":539816,"node":151,"role":"declaration","source":0,"src_end":433667,"src_start":432987},{"artifact":0,"gen_end":540853,"gen_start":540653,"node":152,"role":"declaration","source":0,"src_end":433901,"src_start":433669},{"artifact":0,"gen_end":540978,"gen_start":540853,"node":153,"role":"declaration","source":0,"src_end":434117,"src_start":433903},{"artifact":0,"gen_end":541686,"gen_start":540978,"node":154,"role":"declaration","source":0,"src_end":434692,"src_start":434119},{"artifact":0,"gen_end":541886,"gen_start":541686,"node":155,"role":"declaration","source":0,"src_end":434926,"src_start":434694},{"artifact":0,"gen_end":542011,"gen_start":541886,"node":156,"role":"declaration","source":0,"src_end":435142,"src_start":434928},{"artifact":0,"gen_end":542982,"gen_start":542011,"node":157,"role":"declaration","source":0,"src_end":435936,"src_start":435144},{"artifact":0,"gen_end":543184,"gen_start":542982,"node":158,"role":"declaration","source":0,"src_end":436172,"src_start":435938},{"artifact":0,"gen_end":543311,"gen_start":543184,"node":159,"role":"declaration","source":0,"src_end":436390,"src_start":436174},{"artifact":0,"gen_end":544149,"gen_start":543311,"node":160,"role":"declaration","source":0,"src_end":437073,"src_start":436392},{"artifact":0,"gen_end":544349,"gen_start":544149,"node":161,"role":"declaration","source":0,"src_end":437307,"src_start":437075},{"artifact":0,"gen_end":544474,"gen_start":544349,"node":162,"role":"declaration","source":0,"src_end":437523,"src_start":437309},{"artifact":0,"gen_end":547049,"gen_start":544474,"node":163,"role":"declaration","source":0,"src_end":439549,"src_start":437525},{"artifact":0,"gen_end":547282,"gen_start":547049,"node":164,"role":"declaration","source":0,"src_end":439810,"src_start":439551},{"artifact":0,"gen_end":547436,"gen_start":547282,"node":165,"role":"declaration","source":0,"src_end":440045,"src_start":439812},{"artifact":0,"gen_end":547666,"gen_start":547436,"node":166,"role":"declaration","source":0,"src_end":440336,"src_start":440047},{"artifact":0,"gen_end":552599,"gen_start":547666,"node":167,"role":"declaration","source":0,"src_end":444150,"src_start":440338},{"artifact":0,"gen_end":552843,"gen_start":552599,"node":168,"role":"declaration","source":0,"src_end":444422,"src_start":444152},{"artifact":0,"gen_end":553093,"gen_start":552843,"node":169,"role":"declaration","source":0,"src_end":444735,"src_start":444424},{"artifact":0,"gen_end":553673,"gen_start":553093,"node":170,"role":"declaration","source":0,"src_end":445365,"src_start":444737},{"artifact":0,"gen_end":558613,"gen_start":553673,"node":171,"role":"declaration","source":0,"src_end":449186,"src_start":445367},{"artifact":0,"gen_end":558870,"gen_start":558613,"node":172,"role":"declaration","source":0,"src_end":449471,"src_start":449188},{"artifact":0,"gen_end":559134,"gen_start":558870,"node":173,"role":"declaration","source":0,"src_end":449798,"src_start":449473},{"artifact":0,"gen_end":559725,"gen_start":559134,"node":174,"role":"declaration","source":0,"src_end":450439,"src_start":449800},{"artifact":0,"gen_end":560577,"gen_start":559725,"node":175,"role":"declaration","source":0,"src_end":451140,"src_start":450441},{"artifact":0,"gen_end":562831,"gen_start":560577,"node":176,"role":"declaration","source":0,"src_end":453134,"src_start":451142},{"artifact":0,"gen_end":564913,"gen_start":562831,"node":177,"role":"declaration","source":0,"src_end":455036,"src_start":453136},{"artifact":0,"gen_end":568109,"gen_start":564913,"node":178,"role":"declaration","source":0,"src_end":457573,"src_start":455038},{"artifact":0,"gen_end":568544,"gen_start":568109,"node":179,"role":"declaration","source":0,"src_end":457997,"src_start":457575},{"artifact":0,"gen_end":568700,"gen_start":568544,"node":180,"role":"declaration","source":0,"src_end":458234,"src_start":457999},{"artifact":0,"gen_end":569069,"gen_start":568700,"node":181,"role":"declaration","source":0,"src_end":458637,"src_start":458236},{"artifact":0,"gen_end":575516,"gen_start":569069,"node":182,"role":"declaration","source":0,"src_end":463681,"src_start":458639},{"artifact":0,"gen_end":575928,"gen_start":575516,"node":183,"role":"declaration","source":0,"src_end":464082,"src_start":463683},{"artifact":0,"gen_end":576933,"gen_start":575928,"node":184,"role":"declaration","source":0,"src_end":464988,"src_start":464084},{"artifact":0,"gen_end":583626,"gen_start":576933,"node":185,"role":"declaration","source":0,"src_end":470464,"src_start":464990},{"artifact":0,"gen_end":583814,"gen_start":583626,"node":186,"role":"declaration","source":0,"src_end":470686,"src_start":470466},{"artifact":0,"gen_end":585760,"gen_start":583814,"node":187,"role":"declaration","source":0,"src_end":472433,"src_start":470688},{"artifact":0,"gen_end":590280,"gen_start":585760,"node":188,"role":"declaration","source":0,"src_end":475937,"src_start":472435},{"artifact":0,"gen_end":590881,"gen_start":590280,"node":189,"role":"declaration","source":0,"src_end":476491,"src_start":475939},{"artifact":0,"gen_end":591045,"gen_start":590881,"node":190,"role":"declaration","source":0,"src_end":476736,"src_start":476493},{"artifact":0,"gen_end":591301,"gen_start":591045,"node":191,"role":"declaration","source":0,"src_end":477112,"src_start":476738},{"artifact":0,"gen_end":594687,"gen_start":591301,"node":192,"role":"declaration","source":0,"src_end":479803,"src_start":477114},{"artifact":0,"gen_end":595234,"gen_start":594687,"node":193,"role":"declaration","source":0,"src_end":480309,"src_start":479805},{"artifact":0,"gen_end":595388,"gen_start":595234,"node":194,"role":"declaration","source":0,"src_end":480544,"src_start":480311},{"artifact":0,"gen_end":595740,"gen_start":595388,"node":195,"role":"declaration","source":0,"src_end":481002,"src_start":480546},{"artifact":0,"gen_end":601351,"gen_start":595740,"node":196,"role":"declaration","source":0,"src_end":485403,"src_start":481004},{"artifact":0,"gen_end":601999,"gen_start":601351,"node":197,"role":"declaration","source":0,"src_end":485998,"src_start":485405},{"artifact":0,"gen_end":602603,"gen_start":601999,"node":198,"role":"declaration","source":0,"src_end":486590,"src_start":486000},{"artifact":0,"gen_end":602992,"gen_start":602603,"node":199,"role":"declaration","source":0,"src_end":487052,"src_start":486592},{"artifact":0,"gen_end":608607,"gen_start":602992,"node":200,"role":"declaration","source":0,"src_end":491457,"src_start":487054},{"artifact":0,"gen_end":609263,"gen_start":608607,"node":201,"role":"declaration","source":0,"src_end":492060,"src_start":491459},{"artifact":0,"gen_end":609875,"gen_start":609263,"node":202,"role":"declaration","source":0,"src_end":492660,"src_start":492062},{"artifact":0,"gen_end":610272,"gen_start":609875,"node":203,"role":"declaration","source":0,"src_end":493130,"src_start":492662},{"artifact":0,"gen_end":615890,"gen_start":610272,"node":204,"role":"declaration","source":0,"src_end":497538,"src_start":493132},{"artifact":0,"gen_end":616552,"gen_start":615890,"node":205,"role":"declaration","source":0,"src_end":498147,"src_start":497540},{"artifact":0,"gen_end":617036,"gen_start":616552,"node":206,"role":"declaration","source":0,"src_end":498643,"src_start":498149},{"artifact":0,"gen_end":617439,"gen_start":617036,"node":207,"role":"declaration","source":0,"src_end":499119,"src_start":498645},{"artifact":0,"gen_end":619622,"gen_start":617439,"node":208,"role":"declaration","source":0,"src_end":500822,"src_start":499121},{"artifact":0,"gen_end":620169,"gen_start":619622,"node":209,"role":"declaration","source":0,"src_end":501328,"src_start":500824},{"artifact":0,"gen_end":620459,"gen_start":620169,"node":210,"role":"declaration","source":0,"src_end":501666,"src_start":501330},{"artifact":0,"gen_end":620745,"gen_start":620459,"node":211,"role":"declaration","source":0,"src_end":502061,"src_start":501668},{"artifact":0,"gen_end":624064,"gen_start":620745,"node":212,"role":"declaration","source":0,"src_end":504649,"src_start":502063},{"artifact":0,"gen_end":624661,"gen_start":624064,"node":213,"role":"declaration","source":0,"src_end":505199,"src_start":504651},{"artifact":0,"gen_end":624862,"gen_start":624661,"node":214,"role":"declaration","source":0,"src_end":505473,"src_start":505201},{"artifact":0,"gen_end":625262,"gen_start":624862,"node":215,"role":"declaration","source":0,"src_end":505990,"src_start":505475},{"artifact":0,"gen_end":628587,"gen_start":625262,"node":216,"role":"declaration","source":0,"src_end":508584,"src_start":505992},{"artifact":0,"gen_end":629196,"gen_start":628587,"node":217,"role":"declaration","source":0,"src_end":509146,"src_start":508586},{"artifact":0,"gen_end":629361,"gen_start":629196,"node":218,"role":"declaration","source":0,"src_end":509394,"src_start":509148},{"artifact":0,"gen_end":629773,"gen_start":629361,"node":219,"role":"declaration","source":0,"src_end":509923,"src_start":509396},{"artifact":0,"gen_end":633357,"gen_start":629773,"node":220,"role":"declaration","source":0,"src_end":512727,"src_start":509925},{"artifact":0,"gen_end":633954,"gen_start":633357,"node":221,"role":"declaration","source":0,"src_end":513277,"src_start":512729},{"artifact":0,"gen_end":634290,"gen_start":633954,"node":222,"role":"declaration","source":0,"src_end":513649,"src_start":513279},{"artifact":0,"gen_end":634673,"gen_start":634290,"node":223,"role":"declaration","source":0,"src_end":514107,"src_start":513651},{"artifact":0,"gen_end":638263,"gen_start":634673,"node":224,"role":"declaration","source":0,"src_end":516917,"src_start":514109},{"artifact":0,"gen_end":638872,"gen_start":638263,"node":225,"role":"declaration","source":0,"src_end":517479,"src_start":516919},{"artifact":0,"gen_end":639354,"gen_start":638872,"node":226,"role":"declaration","source":0,"src_end":517973,"src_start":517481},{"artifact":0,"gen_end":639749,"gen_start":639354,"node":227,"role":"declaration","source":0,"src_end":518443,"src_start":517975},{"artifact":0,"gen_end":641950,"gen_start":639749,"node":228,"role":"declaration","source":0,"src_end":520164,"src_start":518445},{"artifact":0,"gen_end":642501,"gen_start":641950,"node":229,"role":"declaration","source":0,"src_end":520674,"src_start":520166},{"artifact":0,"gen_end":642805,"gen_start":642501,"node":230,"role":"declaration","source":0,"src_end":521026,"src_start":520676},{"artifact":0,"gen_end":643103,"gen_start":642805,"node":231,"role":"declaration","source":0,"src_end":521433,"src_start":521028},{"artifact":0,"gen_end":657113,"gen_start":643103,"node":232,"role":"declaration","source":0,"src_end":532181,"src_start":521435},{"artifact":0,"gen_end":657714,"gen_start":657113,"node":233,"role":"declaration","source":0,"src_end":532741,"src_start":532183},{"artifact":0,"gen_end":658750,"gen_start":657714,"node":234,"role":"declaration","source":0,"src_end":533667,"src_start":532743},{"artifact":0,"gen_end":668664,"gen_start":658750,"node":235,"role":"declaration","source":0,"src_end":541388,"src_start":533669},{"artifact":0,"gen_end":668862,"gen_start":668664,"node":236,"role":"declaration","source":0,"src_end":541620,"src_start":541390},{"artifact":0,"gen_end":669893,"gen_start":668862,"node":237,"role":"declaration","source":0,"src_end":542588,"src_start":541622},{"artifact":0,"gen_end":670715,"gen_start":669893,"node":238,"role":"declaration","source":0,"src_end":543255,"src_start":542590},{"artifact":0,"gen_end":670915,"gen_start":670715,"node":239,"role":"declaration","source":0,"src_end":543489,"src_start":543257},{"artifact":0,"gen_end":671040,"gen_start":670915,"node":240,"role":"declaration","source":0,"src_end":543705,"src_start":543491},{"artifact":0,"gen_end":671861,"gen_start":671040,"node":241,"role":"declaration","source":0,"src_end":544371,"src_start":543707},{"artifact":0,"gen_end":672061,"gen_start":671861,"node":242,"role":"declaration","source":0,"src_end":544605,"src_start":544373},{"artifact":0,"gen_end":672186,"gen_start":672061,"node":243,"role":"declaration","source":0,"src_end":544821,"src_start":544607},{"artifact":0,"gen_end":673264,"gen_start":672186,"node":244,"role":"declaration","source":0,"src_end":545687,"src_start":544823},{"artifact":0,"gen_end":673470,"gen_start":673264,"node":245,"role":"declaration","source":0,"src_end":545927,"src_start":545689},{"artifact":0,"gen_end":673601,"gen_start":673470,"node":246,"role":"declaration","source":0,"src_end":546149,"src_start":545929},{"artifact":0,"gen_end":674338,"gen_start":673601,"node":247,"role":"declaration","source":0,"src_end":546745,"src_start":546151},{"artifact":0,"gen_end":674540,"gen_start":674338,"node":248,"role":"declaration","source":0,"src_end":546981,"src_start":546747},{"artifact":0,"gen_end":674667,"gen_start":674540,"node":249,"role":"declaration","source":0,"src_end":547199,"src_start":546983},{"artifact":0,"gen_end":692365,"gen_start":674667,"node":250,"role":"declaration","source":0,"src_end":560813,"src_start":547201},{"artifact":0,"gen_end":692553,"gen_start":692365,"node":251,"role":"declaration","source":0,"src_end":561035,"src_start":560815},{"artifact":0,"gen_end":693604,"gen_start":692553,"node":252,"role":"declaration","source":0,"src_end":562011,"src_start":561037},{"artifact":0,"gen_end":695652,"gen_start":693604,"node":253,"role":"declaration","source":0,"src_end":563607,"src_start":562013},{"artifact":0,"gen_end":696164,"gen_start":695652,"node":254,"role":"declaration","source":0,"src_end":564088,"src_start":563609},{"artifact":0,"gen_end":696335,"gen_start":696164,"node":255,"role":"declaration","source":0,"src_end":564340,"src_start":564090},{"artifact":0,"gen_end":698274,"gen_start":696335,"node":256,"role":"declaration","source":0,"src_end":565874,"src_start":564342},{"artifact":0,"gen_end":698704,"gen_start":698274,"node":257,"role":"declaration","source":0,"src_end":566291,"src_start":565876},{"artifact":0,"gen_end":699033,"gen_start":698704,"node":258,"role":"declaration","source":0,"src_end":566665,"src_start":566293},{"artifact":0,"gen_end":701791,"gen_start":699033,"node":259,"role":"declaration","source":0,"src_end":568802,"src_start":566667},{"artifact":0,"gen_end":702262,"gen_start":701791,"node":260,"role":"declaration","source":0,"src_end":569256,"src_start":568804},{"artifact":0,"gen_end":702426,"gen_start":702262,"node":261,"role":"declaration","source":0,"src_end":569501,"src_start":569258},{"artifact":0,"gen_end":702655,"gen_start":702426,"node":262,"role":"declaration","source":0,"src_end":569828,"src_start":569503},{"artifact":0,"gen_end":705419,"gen_start":702655,"node":263,"role":"declaration","source":0,"src_end":571971,"src_start":569830},{"artifact":0,"gen_end":705902,"gen_start":705419,"node":264,"role":"declaration","source":0,"src_end":572437,"src_start":571973},{"artifact":0,"gen_end":706079,"gen_start":705902,"node":265,"role":"declaration","source":0,"src_end":572695,"src_start":572439},{"artifact":0,"gen_end":706320,"gen_start":706079,"node":266,"role":"declaration","source":0,"src_end":573034,"src_start":572697},{"artifact":0,"gen_end":710993,"gen_start":706320,"node":267,"role":"declaration","source":0,"src_end":576645,"src_start":573036},{"artifact":0,"gen_end":711652,"gen_start":710993,"node":268,"role":"declaration","source":0,"src_end":577248,"src_start":576647},{"artifact":0,"gen_end":711955,"gen_start":711652,"node":269,"role":"declaration","source":0,"src_end":577599,"src_start":577250},{"artifact":0,"gen_end":712308,"gen_start":711955,"node":270,"role":"declaration","source":0,"src_end":578043,"src_start":577601},{"artifact":0,"gen_end":715270,"gen_start":712308,"node":271,"role":"declaration","source":0,"src_end":580389,"src_start":578045},{"artifact":0,"gen_end":715687,"gen_start":715270,"node":272,"role":"declaration","source":0,"src_end":580795,"src_start":580391},{"artifact":0,"gen_end":715842,"gen_start":715687,"node":273,"role":"declaration","source":0,"src_end":581031,"src_start":580797},{"artifact":0,"gen_end":716156,"gen_start":715842,"node":274,"role":"declaration","source":0,"src_end":581427,"src_start":581033},{"artifact":0,"gen_end":719606,"gen_start":716156,"node":275,"role":"declaration","source":0,"src_end":584119,"src_start":581429},{"artifact":0,"gen_end":719998,"gen_start":719606,"node":276,"role":"declaration","source":0,"src_end":584506,"src_start":584121},{"artifact":0,"gen_end":720309,"gen_start":719998,"node":277,"role":"declaration","source":0,"src_end":584865,"src_start":584508},{"artifact":0,"gen_end":720639,"gen_start":720309,"node":278,"role":"declaration","source":0,"src_end":585264,"src_start":584867},{"artifact":0,"gen_end":724076,"gen_start":720639,"node":279,"role":"declaration","source":0,"src_end":587943,"src_start":585266},{"artifact":0,"gen_end":724529,"gen_start":724076,"node":280,"role":"declaration","source":0,"src_end":588385,"src_start":587945},{"artifact":0,"gen_end":724901,"gen_start":724529,"node":281,"role":"declaration","source":0,"src_end":588799,"src_start":588387},{"artifact":0,"gen_end":725247,"gen_start":724901,"node":282,"role":"declaration","source":0,"src_end":589214,"src_start":588801},{"artifact":0,"gen_end":729189,"gen_start":725247,"node":283,"role":"declaration","source":0,"src_end":592302,"src_start":589216},{"artifact":0,"gen_end":729646,"gen_start":729189,"node":284,"role":"declaration","source":0,"src_end":592748,"src_start":592304},{"artifact":0,"gen_end":730022,"gen_start":729646,"node":285,"role":"declaration","source":0,"src_end":593166,"src_start":592750},{"artifact":0,"gen_end":730377,"gen_start":730022,"node":286,"role":"declaration","source":0,"src_end":593590,"src_start":593168},{"artifact":0,"gen_end":733814,"gen_start":730377,"node":287,"role":"declaration","source":0,"src_end":596269,"src_start":593592},{"artifact":0,"gen_end":734287,"gen_start":733814,"node":288,"role":"declaration","source":0,"src_end":596725,"src_start":596271},{"artifact":0,"gen_end":734679,"gen_start":734287,"node":289,"role":"declaration","source":0,"src_end":597153,"src_start":596727},{"artifact":0,"gen_end":735002,"gen_start":734679,"node":290,"role":"declaration","source":0,"src_end":597545,"src_start":597155},{"artifact":0,"gen_end":739355,"gen_start":735002,"node":291,"role":"declaration","source":0,"src_end":600948,"src_start":597547},{"artifact":0,"gen_end":740054,"gen_start":739355,"node":292,"role":"declaration","source":0,"src_end":601582,"src_start":600950},{"artifact":0,"gen_end":740672,"gen_start":740054,"node":293,"role":"declaration","source":0,"src_end":602188,"src_start":601584},{"artifact":0,"gen_end":741081,"gen_start":740672,"node":294,"role":"declaration","source":0,"src_end":602645,"src_start":602190},{"artifact":0,"gen_end":744557,"gen_start":741081,"node":295,"role":"declaration","source":0,"src_end":605363,"src_start":602647},{"artifact":0,"gen_end":745006,"gen_start":744557,"node":296,"role":"declaration","source":0,"src_end":605801,"src_start":605365},{"artifact":0,"gen_end":745374,"gen_start":745006,"node":297,"role":"declaration","source":0,"src_end":606211,"src_start":605803},{"artifact":0,"gen_end":745719,"gen_start":745374,"node":298,"role":"declaration","source":0,"src_end":606625,"src_start":606213},{"artifact":0,"gen_end":750394,"gen_start":745719,"node":299,"role":"declaration","source":0,"src_end":610238,"src_start":606627},{"artifact":0,"gen_end":751057,"gen_start":750394,"node":300,"role":"declaration","source":0,"src_end":610845,"src_start":610240},{"artifact":0,"gen_end":751318,"gen_start":751057,"node":301,"role":"declaration","source":0,"src_end":611160,"src_start":610847},{"artifact":0,"gen_end":751677,"gen_start":751318,"node":302,"role":"declaration","source":0,"src_end":611610,"src_start":611162},{"artifact":0,"gen_end":754613,"gen_start":751677,"node":303,"role":"declaration","source":0,"src_end":613902,"src_start":611612},{"artifact":0,"gen_end":755080,"gen_start":754613,"node":304,"role":"declaration","source":0,"src_end":614352,"src_start":613904},{"artifact":0,"gen_end":755374,"gen_start":755080,"node":305,"role":"declaration","source":0,"src_end":614694,"src_start":614354},{"artifact":0,"gen_end":755691,"gen_start":755374,"node":306,"role":"declaration","source":0,"src_end":615080,"src_start":614696},{"artifact":0,"gen_end":758633,"gen_start":755691,"node":307,"role":"declaration","source":0,"src_end":617378,"src_start":615082},{"artifact":0,"gen_end":759112,"gen_start":758633,"node":308,"role":"declaration","source":0,"src_end":617840,"src_start":617380},{"artifact":0,"gen_end":759464,"gen_start":759112,"node":309,"role":"declaration","source":0,"src_end":618234,"src_start":617842},{"artifact":0,"gen_end":759793,"gen_start":759464,"node":310,"role":"declaration","source":0,"src_end":618632,"src_start":618236},{"artifact":0,"gen_end":764434,"gen_start":759793,"node":311,"role":"declaration","source":0,"src_end":622247,"src_start":618634},{"artifact":0,"gen_end":765083,"gen_start":764434,"node":312,"role":"declaration","source":0,"src_end":622840,"src_start":622249},{"artifact":0,"gen_end":765514,"gen_start":765083,"node":313,"role":"declaration","source":0,"src_end":623301,"src_start":622842},{"artifact":0,"gen_end":765852,"gen_start":765514,"node":314,"role":"declaration","source":0,"src_end":623730,"src_start":623303},{"artifact":0,"gen_end":774593,"gen_start":765852,"node":315,"role":"declaration","source":0,"src_end":630646,"src_start":623732},{"artifact":0,"gen_end":774789,"gen_start":774593,"node":316,"role":"declaration","source":0,"src_end":630876,"src_start":630648},{"artifact":0,"gen_end":776268,"gen_start":774789,"node":317,"role":"declaration","source":0,"src_end":632082,"src_start":630878},{"artifact":0,"gen_end":776512,"gen_start":776268,"node":318,"role":"declaration","source":0,"src_end":632354,"src_start":632084},{"artifact":0,"gen_end":776825,"gen_start":776512,"node":319,"role":"declaration","source":0,"src_end":632730,"src_start":632356},{"artifact":0,"gen_end":778267,"gen_start":776825,"node":320,"role":"declaration","source":0,"src_end":633854,"src_start":632732},{"artifact":0,"gen_end":778497,"gen_start":778267,"node":321,"role":"declaration","source":0,"src_end":634112,"src_start":633856},{"artifact":0,"gen_end":778647,"gen_start":778497,"node":322,"role":"declaration","source":0,"src_end":634343,"src_start":634114},{"artifact":0,"gen_end":780098,"gen_start":778647,"node":323,"role":"declaration","source":0,"src_end":635476,"src_start":634345},{"artifact":0,"gen_end":780344,"gen_start":780098,"node":324,"role":"declaration","source":0,"src_end":635750,"src_start":635478},{"artifact":0,"gen_end":780466,"gen_start":780344,"node":325,"role":"declaration","source":0,"src_end":635965,"src_start":635752},{"artifact":0,"gen_end":786019,"gen_start":780466,"node":326,"role":"declaration","source":0,"src_end":640246,"src_start":635967},{"artifact":0,"gen_end":786261,"gen_start":786019,"node":327,"role":"declaration","source":0,"src_end":640516,"src_start":640248},{"artifact":0,"gen_end":786700,"gen_start":786261,"node":328,"role":"declaration","source":0,"src_end":640982,"src_start":640518},{"artifact":0,"gen_end":793439,"gen_start":786700,"node":329,"role":"declaration","source":0,"src_end":646140,"src_start":640984},{"artifact":0,"gen_end":793720,"gen_start":793439,"node":330,"role":"declaration","source":0,"src_end":646445,"src_start":646142},{"artifact":0,"gen_end":793995,"gen_start":793720,"node":331,"role":"declaration","source":0,"src_end":646779,"src_start":646447},{"artifact":0,"gen_end":802125,"gen_start":793995,"node":332,"role":"declaration","source":0,"src_end":653341,"src_start":646781},{"artifact":0,"gen_end":802363,"gen_start":802125,"node":333,"role":"declaration","source":0,"src_end":653607,"src_start":653343},{"artifact":0,"gen_end":802763,"gen_start":802363,"node":334,"role":"declaration","source":0,"src_end":654038,"src_start":653609},{"artifact":0,"gen_end":802797,"gen_start":802763,"node":0,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":335,"role":"declaration","source":0,"src_end":654074,"src_start":0},{"artifact":1,"gen_end":4662,"gen_start":134,"node":336,"role":"declaration","source":0,"src_end":3550,"src_start":210},{"artifact":1,"gen_end":5047,"gen_start":4662,"node":337,"role":"declaration","source":0,"src_end":3782,"src_start":3552},{"artifact":1,"gen_end":5362,"gen_start":5047,"node":338,"role":"declaration","source":0,"src_end":4028,"src_start":3784},{"artifact":1,"gen_end":11423,"gen_start":5362,"node":339,"role":"declaration","source":0,"src_end":8546,"src_start":4030},{"artifact":1,"gen_end":11860,"gen_start":11423,"node":340,"role":"declaration","source":0,"src_end":8824,"src_start":8548},{"artifact":1,"gen_end":12536,"gen_start":11860,"node":341,"role":"declaration","source":0,"src_end":9359,"src_start":8826},{"artifact":1,"gen_end":23711,"gen_start":12536,"node":342,"role":"declaration","source":0,"src_end":17744,"src_start":9361},{"artifact":1,"gen_end":24243,"gen_start":23711,"node":343,"role":"declaration","source":0,"src_end":18105,"src_start":17746},{"artifact":1,"gen_end":25244,"gen_start":24243,"node":344,"role":"declaration","source":0,"src_end":18893,"src_start":18107},{"artifact":1,"gen_end":28814,"gen_start":25244,"node":345,"role":"declaration","source":0,"src_end":21516,"src_start":18895},{"artifact":1,"gen_end":29290,"gen_start":28814,"node":346,"role":"declaration","source":0,"src_end":21827,"src_start":21518},{"artifact":1,"gen_end":29894,"gen_start":29290,"node":347,"role":"declaration","source":0,"src_end":22311,"src_start":21829},{"artifact":1,"gen_end":31441,"gen_start":29894,"node":348,"role":"declaration","source":0,"src_end":23401,"src_start":22313},{"artifact":1,"gen_end":32185,"gen_start":31441,"node":349,"role":"declaration","source":0,"src_end":23910,"src_start":23403},{"artifact":1,"gen_end":32492,"gen_start":32185,"node":350,"role":"declaration","source":0,"src_end":24148,"src_start":23912},{"artifact":1,"gen_end":35867,"gen_start":32492,"node":351,"role":"declaration","source":0,"src_end":26592,"src_start":24150},{"artifact":1,"gen_end":36248,"gen_start":35867,"node":352,"role":"declaration","source":0,"src_end":26820,"src_start":26594},{"artifact":1,"gen_end":42499,"gen_start":36248,"node":353,"role":"declaration","source":0,"src_end":31444,"src_start":26822},{"artifact":1,"gen_end":42876,"gen_start":42499,"node":354,"role":"declaration","source":0,"src_end":31668,"src_start":31446},{"artifact":1,"gen_end":46094,"gen_start":42876,"node":355,"role":"declaration","source":0,"src_end":34045,"src_start":31670},{"artifact":1,"gen_end":46473,"gen_start":46094,"node":356,"role":"declaration","source":0,"src_end":34271,"src_start":34047},{"artifact":1,"gen_end":47084,"gen_start":46473,"node":357,"role":"declaration","source":0,"src_end":34728,"src_start":34273},{"artifact":1,"gen_end":54281,"gen_start":47084,"node":358,"role":"declaration","source":0,"src_end":40112,"src_start":34730},{"artifact":1,"gen_end":54664,"gen_start":54281,"node":359,"role":"declaration","source":0,"src_end":40342,"src_start":40114},{"artifact":1,"gen_end":55764,"gen_start":54664,"node":360,"role":"declaration","source":0,"src_end":41184,"src_start":40344},{"artifact":1,"gen_end":58237,"gen_start":55764,"node":361,"role":"declaration","source":0,"src_end":43042,"src_start":41186},{"artifact":1,"gen_end":58765,"gen_start":58237,"node":362,"role":"declaration","source":0,"src_end":43399,"src_start":43044},{"artifact":1,"gen_end":59085,"gen_start":58765,"node":363,"role":"declaration","source":0,"src_end":43650,"src_start":43401},{"artifact":1,"gen_end":62888,"gen_start":59085,"node":364,"role":"declaration","source":0,"src_end":46530,"src_start":43652},{"artifact":1,"gen_end":63376,"gen_start":62888,"node":365,"role":"declaration","source":0,"src_end":46853,"src_start":46532},{"artifact":1,"gen_end":63778,"gen_start":63376,"node":366,"role":"declaration","source":0,"src_end":47168,"src_start":46855},{"artifact":1,"gen_end":65567,"gen_start":63778,"node":367,"role":"declaration","source":0,"src_end":48492,"src_start":47170},{"artifact":1,"gen_end":66045,"gen_start":65567,"node":368,"role":"declaration","source":0,"src_end":48805,"src_start":48494},{"artifact":1,"gen_end":66361,"gen_start":66045,"node":369,"role":"declaration","source":0,"src_end":49052,"src_start":48807},{"artifact":1,"gen_end":69185,"gen_start":66361,"node":370,"role":"declaration","source":0,"src_end":51097,"src_start":49054},{"artifact":1,"gen_end":69622,"gen_start":69185,"node":371,"role":"declaration","source":0,"src_end":51375,"src_start":51099},{"artifact":1,"gen_end":69942,"gen_start":69622,"node":372,"role":"declaration","source":0,"src_end":51626,"src_start":51377},{"artifact":1,"gen_end":72656,"gen_start":69942,"node":373,"role":"declaration","source":0,"src_end":53608,"src_start":51628},{"artifact":1,"gen_end":73097,"gen_start":72656,"node":374,"role":"declaration","source":0,"src_end":53890,"src_start":53610},{"artifact":1,"gen_end":73420,"gen_start":73097,"node":375,"role":"declaration","source":0,"src_end":54144,"src_start":53892},{"artifact":1,"gen_end":74803,"gen_start":73420,"node":376,"role":"declaration","source":0,"src_end":55131,"src_start":54146},{"artifact":1,"gen_end":75232,"gen_start":74803,"node":377,"role":"declaration","source":0,"src_end":55401,"src_start":55133},{"artifact":1,"gen_end":75642,"gen_start":75232,"node":378,"role":"declaration","source":0,"src_end":55713,"src_start":55403},{"artifact":1,"gen_end":78829,"gen_start":75642,"node":379,"role":"declaration","source":0,"src_end":58081,"src_start":55715},{"artifact":1,"gen_end":79481,"gen_start":78829,"node":380,"role":"declaration","source":0,"src_end":58529,"src_start":58083},{"artifact":1,"gen_end":79972,"gen_start":79481,"node":381,"role":"declaration","source":0,"src_end":58912,"src_start":58531},{"artifact":1,"gen_end":84554,"gen_start":79972,"node":382,"role":"declaration","source":0,"src_end":62449,"src_start":58914},{"artifact":1,"gen_end":84927,"gen_start":84554,"node":383,"role":"declaration","source":0,"src_end":62669,"src_start":62451},{"artifact":1,"gen_end":85873,"gen_start":84927,"node":384,"role":"declaration","source":0,"src_end":63451,"src_start":62671},{"artifact":1,"gen_end":96993,"gen_start":85873,"node":385,"role":"declaration","source":0,"src_end":71974,"src_start":63453},{"artifact":1,"gen_end":97366,"gen_start":96993,"node":386,"role":"declaration","source":0,"src_end":72194,"src_start":71976},{"artifact":1,"gen_end":98305,"gen_start":97366,"node":387,"role":"declaration","source":0,"src_end":72834,"src_start":72196},{"artifact":1,"gen_end":98694,"gen_start":98305,"node":388,"role":"declaration","source":0,"src_end":73070,"src_start":72836},{"artifact":1,"gen_end":99659,"gen_start":98694,"node":389,"role":"declaration","source":0,"src_end":73736,"src_start":73072},{"artifact":1,"gen_end":100056,"gen_start":99659,"node":390,"role":"declaration","source":0,"src_end":73980,"src_start":73738},{"artifact":1,"gen_end":105663,"gen_start":100056,"node":391,"role":"declaration","source":0,"src_end":78216,"src_start":73982},{"artifact":1,"gen_end":106038,"gen_start":105663,"node":392,"role":"declaration","source":0,"src_end":78438,"src_start":78218},{"artifact":1,"gen_end":106741,"gen_start":106038,"node":393,"role":"declaration","source":0,"src_end":79009,"src_start":78440},{"artifact":1,"gen_end":108666,"gen_start":106741,"node":394,"role":"declaration","source":0,"src_end":80400,"src_start":79011},{"artifact":1,"gen_end":109115,"gen_start":108666,"node":395,"role":"declaration","source":0,"src_end":80690,"src_start":80402},{"artifact":1,"gen_end":109451,"gen_start":109115,"node":396,"role":"declaration","source":0,"src_end":80957,"src_start":80692},{"artifact":1,"gen_end":117105,"gen_start":109451,"node":397,"role":"declaration","source":0,"src_end":86862,"src_start":80959},{"artifact":1,"gen_end":117494,"gen_start":117105,"node":398,"role":"declaration","source":0,"src_end":87098,"src_start":86864},{"artifact":1,"gen_end":118581,"gen_start":117494,"node":399,"role":"declaration","source":0,"src_end":87978,"src_start":87100},{"artifact":1,"gen_end":126205,"gen_start":118581,"node":400,"role":"declaration","source":0,"src_end":93861,"src_start":87980},{"artifact":1,"gen_end":126598,"gen_start":126205,"node":401,"role":"declaration","source":0,"src_end":94101,"src_start":93863},{"artifact":1,"gen_end":127598,"gen_start":126598,"node":402,"role":"declaration","source":0,"src_end":94912,"src_start":94103},{"artifact":1,"gen_end":140962,"gen_start":127598,"node":403,"role":"declaration","source":0,"src_end":105303,"src_start":94914},{"artifact":1,"gen_end":141357,"gen_start":140962,"node":404,"role":"declaration","source":0,"src_end":105545,"src_start":105305},{"artifact":1,"gen_end":142958,"gen_start":141357,"node":405,"role":"declaration","source":0,"src_end":106810,"src_start":105547},{"artifact":1,"gen_end":151261,"gen_start":142958,"node":406,"role":"declaration","source":0,"src_end":113236,"src_start":106812},{"artifact":1,"gen_end":151656,"gen_start":151261,"node":407,"role":"declaration","source":0,"src_end":113478,"src_start":113238},{"artifact":1,"gen_end":152667,"gen_start":151656,"node":408,"role":"declaration","source":0,"src_end":114319,"src_start":113480},{"artifact":1,"gen_end":163905,"gen_start":152667,"node":409,"role":"declaration","source":0,"src_end":123112,"src_start":114321},{"artifact":1,"gen_end":164296,"gen_start":163905,"node":410,"role":"declaration","source":0,"src_end":123350,"src_start":123114},{"artifact":1,"gen_end":165596,"gen_start":164296,"node":411,"role":"declaration","source":0,"src_end":124433,"src_start":123352},{"artifact":1,"gen_end":167240,"gen_start":165596,"node":412,"role":"declaration","source":0,"src_end":125634,"src_start":124435},{"artifact":1,"gen_end":167745,"gen_start":167240,"node":413,"role":"declaration","source":0,"src_end":125974,"src_start":125636},{"artifact":1,"gen_end":169389,"gen_start":167745,"node":414,"role":"declaration","source":0,"src_end":127175,"src_start":125976},{"artifact":1,"gen_end":169904,"gen_start":169389,"node":415,"role":"declaration","source":0,"src_end":127525,"src_start":127177},{"artifact":1,"gen_end":171548,"gen_start":169904,"node":416,"role":"declaration","source":0,"src_end":128726,"src_start":127527},{"artifact":1,"gen_end":172081,"gen_start":171548,"node":417,"role":"declaration","source":0,"src_end":129094,"src_start":128728},{"artifact":1,"gen_end":173720,"gen_start":172081,"node":418,"role":"declaration","source":0,"src_end":130290,"src_start":129096},{"artifact":1,"gen_end":174217,"gen_start":173720,"node":419,"role":"declaration","source":0,"src_end":130622,"src_start":130292},{"artifact":1,"gen_end":175861,"gen_start":174217,"node":420,"role":"declaration","source":0,"src_end":131823,"src_start":130624},{"artifact":1,"gen_end":176362,"gen_start":175861,"node":421,"role":"declaration","source":0,"src_end":132159,"src_start":131825},{"artifact":1,"gen_end":178006,"gen_start":176362,"node":422,"role":"declaration","source":0,"src_end":133360,"src_start":132161},{"artifact":1,"gen_end":178512,"gen_start":178006,"node":423,"role":"declaration","source":0,"src_end":133701,"src_start":133362},{"artifact":1,"gen_end":180156,"gen_start":178512,"node":424,"role":"declaration","source":0,"src_end":134902,"src_start":133703},{"artifact":1,"gen_end":180672,"gen_start":180156,"node":425,"role":"declaration","source":0,"src_end":135253,"src_start":134904},{"artifact":1,"gen_end":182311,"gen_start":180672,"node":426,"role":"declaration","source":0,"src_end":136449,"src_start":135255},{"artifact":1,"gen_end":182806,"gen_start":182311,"node":427,"role":"declaration","source":0,"src_end":136779,"src_start":136451},{"artifact":1,"gen_end":205438,"gen_start":182806,"node":428,"role":"declaration","source":0,"src_end":154522,"src_start":136781},{"artifact":1,"gen_end":206001,"gen_start":205438,"node":429,"role":"declaration","source":0,"src_end":154914,"src_start":154524},{"artifact":1,"gen_end":207871,"gen_start":206001,"node":430,"role":"declaration","source":0,"src_end":156415,"src_start":154916},{"artifact":1,"gen_end":230503,"gen_start":207871,"node":431,"role":"declaration","source":0,"src_end":174158,"src_start":156417},{"artifact":1,"gen_end":231076,"gen_start":230503,"node":432,"role":"declaration","source":0,"src_end":174560,"src_start":174160},{"artifact":1,"gen_end":232961,"gen_start":231076,"node":433,"role":"declaration","source":0,"src_end":176076,"src_start":174562},{"artifact":1,"gen_end":255593,"gen_start":232961,"node":434,"role":"declaration","source":0,"src_end":193819,"src_start":176078},{"artifact":1,"gen_end":256184,"gen_start":255593,"node":435,"role":"declaration","source":0,"src_end":194239,"src_start":193821},{"artifact":1,"gen_end":258097,"gen_start":256184,"node":436,"role":"declaration","source":0,"src_end":195783,"src_start":194241},{"artifact":1,"gen_end":280620,"gen_start":258097,"node":437,"role":"declaration","source":0,"src_end":213417,"src_start":195785},{"artifact":1,"gen_end":281173,"gen_start":280620,"node":438,"role":"declaration","source":0,"src_end":213799,"src_start":213419},{"artifact":1,"gen_end":282962,"gen_start":281173,"node":439,"role":"declaration","source":0,"src_end":215229,"src_start":213801},{"artifact":1,"gen_end":303154,"gen_start":282962,"node":440,"role":"declaration","source":0,"src_end":231048,"src_start":215231},{"artifact":1,"gen_end":303714,"gen_start":303154,"node":441,"role":"declaration","source":0,"src_end":231437,"src_start":231050},{"artifact":1,"gen_end":305412,"gen_start":303714,"node":442,"role":"declaration","source":0,"src_end":232802,"src_start":231439},{"artifact":1,"gen_end":325604,"gen_start":305412,"node":443,"role":"declaration","source":0,"src_end":248621,"src_start":232804},{"artifact":1,"gen_end":326169,"gen_start":325604,"node":444,"role":"declaration","source":0,"src_end":249015,"src_start":248623},{"artifact":1,"gen_end":327892,"gen_start":326169,"node":445,"role":"declaration","source":0,"src_end":250405,"src_start":249017},{"artifact":1,"gen_end":348084,"gen_start":327892,"node":446,"role":"declaration","source":0,"src_end":266224,"src_start":250407},{"artifact":1,"gen_end":348659,"gen_start":348084,"node":447,"role":"declaration","source":0,"src_end":266628,"src_start":266226},{"artifact":1,"gen_end":350431,"gen_start":348659,"node":448,"role":"declaration","source":0,"src_end":268067,"src_start":266630},{"artifact":1,"gen_end":370528,"gen_start":350431,"node":449,"role":"declaration","source":0,"src_end":283791,"src_start":268069},{"artifact":1,"gen_end":371080,"gen_start":370528,"node":450,"role":"declaration","source":0,"src_end":284172,"src_start":283793},{"artifact":1,"gen_end":372695,"gen_start":371080,"node":451,"role":"declaration","source":0,"src_end":285464,"src_start":284174},{"artifact":1,"gen_end":390843,"gen_start":372695,"node":452,"role":"declaration","source":0,"src_end":299241,"src_start":285466},{"artifact":1,"gen_end":391230,"gen_start":390843,"node":453,"role":"declaration","source":0,"src_end":299475,"src_start":299243},{"artifact":1,"gen_end":392329,"gen_start":391230,"node":454,"role":"declaration","source":0,"src_end":300339,"src_start":299477},{"artifact":1,"gen_end":419711,"gen_start":392329,"node":455,"role":"declaration","source":0,"src_end":321194,"src_start":300341},{"artifact":1,"gen_end":421121,"gen_start":419711,"node":456,"role":"declaration","source":0,"src_end":322214,"src_start":321196},{"artifact":1,"gen_end":421669,"gen_start":421121,"node":457,"role":"declaration","source":0,"src_end":322648,"src_start":322216},{"artifact":1,"gen_end":422205,"gen_start":421669,"node":458,"role":"declaration","source":0,"src_end":323189,"src_start":322650},{"artifact":1,"gen_end":449593,"gen_start":422205,"node":459,"role":"declaration","source":0,"src_end":344050,"src_start":323191},{"artifact":1,"gen_end":451015,"gen_start":449593,"node":460,"role":"declaration","source":0,"src_end":345082,"src_start":344052},{"artifact":1,"gen_end":451436,"gen_start":451015,"node":461,"role":"declaration","source":0,"src_end":345407,"src_start":345084},{"artifact":1,"gen_end":451983,"gen_start":451436,"node":462,"role":"declaration","source":0,"src_end":345959,"src_start":345409},{"artifact":1,"gen_end":479370,"gen_start":451983,"node":463,"role":"declaration","source":0,"src_end":366819,"src_start":345961},{"artifact":1,"gen_end":480790,"gen_start":479370,"node":464,"role":"declaration","source":0,"src_end":367849,"src_start":366821},{"artifact":1,"gen_end":481256,"gen_start":480790,"node":465,"role":"declaration","source":0,"src_end":368213,"src_start":367851},{"artifact":1,"gen_end":481802,"gen_start":481256,"node":466,"role":"declaration","source":0,"src_end":368764,"src_start":368215},{"artifact":1,"gen_end":486841,"gen_start":481802,"node":467,"role":"declaration","source":0,"src_end":372530,"src_start":368766},{"artifact":1,"gen_end":488253,"gen_start":486841,"node":468,"role":"declaration","source":0,"src_end":373552,"src_start":372532},{"artifact":1,"gen_end":488709,"gen_start":488253,"node":469,"role":"declaration","source":0,"src_end":373906,"src_start":373554},{"artifact":1,"gen_end":489246,"gen_start":488709,"node":470,"role":"declaration","source":0,"src_end":374448,"src_start":373908},{"artifact":1,"gen_end":494291,"gen_start":489246,"node":471,"role":"declaration","source":0,"src_end":378220,"src_start":374450},{"artifact":1,"gen_end":495715,"gen_start":494291,"node":472,"role":"declaration","source":0,"src_end":379254,"src_start":378222},{"artifact":1,"gen_end":496092,"gen_start":495715,"node":473,"role":"declaration","source":0,"src_end":379541,"src_start":379256},{"artifact":1,"gen_end":496642,"gen_start":496092,"node":474,"role":"declaration","source":0,"src_end":380096,"src_start":379543},{"artifact":1,"gen_end":523330,"gen_start":496642,"node":475,"role":"declaration","source":0,"src_end":400342,"src_start":380098},{"artifact":1,"gen_end":524698,"gen_start":523330,"node":476,"role":"declaration","source":0,"src_end":401326,"src_start":400344},{"artifact":1,"gen_end":525290,"gen_start":524698,"node":477,"role":"declaration","source":0,"src_end":401796,"src_start":401328},{"artifact":1,"gen_end":525927,"gen_start":525290,"node":478,"role":"declaration","source":0,"src_end":402462,"src_start":401798},{"artifact":1,"gen_end":552620,"gen_start":525927,"node":479,"role":"declaration","source":0,"src_end":422713,"src_start":402464},{"artifact":1,"gen_end":553777,"gen_start":552620,"node":480,"role":"declaration","source":0,"src_end":423537,"src_start":422715},{"artifact":1,"gen_end":554106,"gen_start":553777,"node":481,"role":"declaration","source":0,"src_end":423799,"src_start":423539},{"artifact":1,"gen_end":554741,"gen_start":554106,"node":482,"role":"declaration","source":0,"src_end":424408,"src_start":423801},{"artifact":1,"gen_end":564291,"gen_start":554741,"node":483,"role":"declaration","source":0,"src_end":431829,"src_start":424410},{"artifact":1,"gen_end":564676,"gen_start":564291,"node":484,"role":"declaration","source":0,"src_end":432061,"src_start":431831},{"artifact":1,"gen_end":565768,"gen_start":564676,"node":485,"role":"declaration","source":0,"src_end":432985,"src_start":432063},{"artifact":1,"gen_end":566755,"gen_start":565768,"node":486,"role":"declaration","source":0,"src_end":433667,"src_start":432987},{"artifact":1,"gen_end":567142,"gen_start":566755,"node":487,"role":"declaration","source":0,"src_end":433901,"src_start":433669},{"artifact":1,"gen_end":567417,"gen_start":567142,"node":488,"role":"declaration","source":0,"src_end":434117,"src_start":433903},{"artifact":1,"gen_end":568275,"gen_start":567417,"node":489,"role":"declaration","source":0,"src_end":434692,"src_start":434119},{"artifact":1,"gen_end":568662,"gen_start":568275,"node":490,"role":"declaration","source":0,"src_end":434926,"src_start":434694},{"artifact":1,"gen_end":568937,"gen_start":568662,"node":491,"role":"declaration","source":0,"src_end":435142,"src_start":434928},{"artifact":1,"gen_end":570058,"gen_start":568937,"node":492,"role":"declaration","source":0,"src_end":435936,"src_start":435144},{"artifact":1,"gen_end":570447,"gen_start":570058,"node":493,"role":"declaration","source":0,"src_end":436172,"src_start":435938},{"artifact":1,"gen_end":570724,"gen_start":570447,"node":494,"role":"declaration","source":0,"src_end":436390,"src_start":436174},{"artifact":1,"gen_end":571712,"gen_start":570724,"node":495,"role":"declaration","source":0,"src_end":437073,"src_start":436392},{"artifact":1,"gen_end":572099,"gen_start":571712,"node":496,"role":"declaration","source":0,"src_end":437307,"src_start":437075},{"artifact":1,"gen_end":572374,"gen_start":572099,"node":497,"role":"declaration","source":0,"src_end":437523,"src_start":437309},{"artifact":1,"gen_end":575115,"gen_start":572374,"node":498,"role":"declaration","source":0,"src_end":439549,"src_start":437525},{"artifact":1,"gen_end":575535,"gen_start":575115,"node":499,"role":"declaration","source":0,"src_end":439810,"src_start":439551},{"artifact":1,"gen_end":575839,"gen_start":575535,"node":500,"role":"declaration","source":0,"src_end":440045,"src_start":439812},{"artifact":1,"gen_end":576219,"gen_start":575839,"node":501,"role":"declaration","source":0,"src_end":440336,"src_start":440047},{"artifact":1,"gen_end":581330,"gen_start":576219,"node":502,"role":"declaration","source":0,"src_end":444150,"src_start":440338},{"artifact":1,"gen_end":581761,"gen_start":581330,"node":503,"role":"declaration","source":0,"src_end":444422,"src_start":444152},{"artifact":1,"gen_end":582161,"gen_start":581761,"node":504,"role":"declaration","source":0,"src_end":444735,"src_start":444424},{"artifact":1,"gen_end":582891,"gen_start":582161,"node":505,"role":"declaration","source":0,"src_end":445365,"src_start":444737},{"artifact":1,"gen_end":588009,"gen_start":582891,"node":506,"role":"declaration","source":0,"src_end":449186,"src_start":445367},{"artifact":1,"gen_end":588453,"gen_start":588009,"node":507,"role":"declaration","source":0,"src_end":449471,"src_start":449188},{"artifact":1,"gen_end":588867,"gen_start":588453,"node":508,"role":"declaration","source":0,"src_end":449798,"src_start":449473},{"artifact":1,"gen_end":589608,"gen_start":588867,"node":509,"role":"declaration","source":0,"src_end":450439,"src_start":449800},{"artifact":1,"gen_end":590610,"gen_start":589608,"node":510,"role":"declaration","source":0,"src_end":451140,"src_start":450441},{"artifact":1,"gen_end":593051,"gen_start":590610,"node":511,"role":"declaration","source":0,"src_end":453134,"src_start":451142},{"artifact":1,"gen_end":595283,"gen_start":593051,"node":512,"role":"declaration","source":0,"src_end":455036,"src_start":453136},{"artifact":1,"gen_end":598645,"gen_start":595283,"node":513,"role":"declaration","source":0,"src_end":457573,"src_start":455038},{"artifact":1,"gen_end":599273,"gen_start":598645,"node":514,"role":"declaration","source":0,"src_end":457997,"src_start":457575},{"artifact":1,"gen_end":599579,"gen_start":599273,"node":515,"role":"declaration","source":0,"src_end":458234,"src_start":457999},{"artifact":1,"gen_end":600104,"gen_start":599579,"node":516,"role":"declaration","source":0,"src_end":458637,"src_start":458236},{"artifact":1,"gen_end":606701,"gen_start":600104,"node":517,"role":"declaration","source":0,"src_end":463681,"src_start":458639},{"artifact":1,"gen_end":607300,"gen_start":606701,"node":518,"role":"declaration","source":0,"src_end":464082,"src_start":463683},{"artifact":1,"gen_end":608455,"gen_start":607300,"node":519,"role":"declaration","source":0,"src_end":464988,"src_start":464084},{"artifact":1,"gen_end":615308,"gen_start":608455,"node":520,"role":"declaration","source":0,"src_end":470464,"src_start":464990},{"artifact":1,"gen_end":615683,"gen_start":615308,"node":521,"role":"declaration","source":0,"src_end":470686,"src_start":470466},{"artifact":1,"gen_end":617785,"gen_start":615683,"node":522,"role":"declaration","source":0,"src_end":472433,"src_start":470688},{"artifact":1,"gen_end":622495,"gen_start":617785,"node":523,"role":"declaration","source":0,"src_end":475937,"src_start":472435},{"artifact":1,"gen_end":623283,"gen_start":622495,"node":524,"role":"declaration","source":0,"src_end":476491,"src_start":475939},{"artifact":1,"gen_end":623597,"gen_start":623283,"node":525,"role":"declaration","source":0,"src_end":476736,"src_start":476493},{"artifact":1,"gen_end":624003,"gen_start":623597,"node":526,"role":"declaration","source":0,"src_end":477112,"src_start":476738},{"artifact":1,"gen_end":627555,"gen_start":624003,"node":527,"role":"declaration","source":0,"src_end":479803,"src_start":477114},{"artifact":1,"gen_end":628289,"gen_start":627555,"node":528,"role":"declaration","source":0,"src_end":480309,"src_start":479805},{"artifact":1,"gen_end":628593,"gen_start":628289,"node":529,"role":"declaration","source":0,"src_end":480544,"src_start":480311},{"artifact":1,"gen_end":629095,"gen_start":628593,"node":530,"role":"declaration","source":0,"src_end":481002,"src_start":480546},{"artifact":1,"gen_end":634882,"gen_start":629095,"node":531,"role":"declaration","source":0,"src_end":485403,"src_start":481004},{"artifact":1,"gen_end":635717,"gen_start":634882,"node":532,"role":"declaration","source":0,"src_end":485998,"src_start":485405},{"artifact":1,"gen_end":636471,"gen_start":635717,"node":533,"role":"declaration","source":0,"src_end":486590,"src_start":486000},{"artifact":1,"gen_end":637002,"gen_start":636471,"node":534,"role":"declaration","source":0,"src_end":487052,"src_start":486592},{"artifact":1,"gen_end":642793,"gen_start":637002,"node":535,"role":"declaration","source":0,"src_end":491457,"src_start":487054},{"artifact":1,"gen_end":643636,"gen_start":642793,"node":536,"role":"declaration","source":0,"src_end":492060,"src_start":491459},{"artifact":1,"gen_end":644398,"gen_start":643636,"node":537,"role":"declaration","source":0,"src_end":492660,"src_start":492062},{"artifact":1,"gen_end":644937,"gen_start":644398,"node":538,"role":"declaration","source":0,"src_end":493130,"src_start":492662},{"artifact":1,"gen_end":650731,"gen_start":644937,"node":539,"role":"declaration","source":0,"src_end":497538,"src_start":493132},{"artifact":1,"gen_end":651580,"gen_start":650731,"node":540,"role":"declaration","source":0,"src_end":498147,"src_start":497540},{"artifact":1,"gen_end":652214,"gen_start":651580,"node":541,"role":"declaration","source":0,"src_end":498643,"src_start":498149},{"artifact":1,"gen_end":652759,"gen_start":652214,"node":542,"role":"declaration","source":0,"src_end":499119,"src_start":498645},{"artifact":1,"gen_end":655106,"gen_start":652759,"node":543,"role":"declaration","source":0,"src_end":500822,"src_start":499121},{"artifact":1,"gen_end":655840,"gen_start":655106,"node":544,"role":"declaration","source":0,"src_end":501328,"src_start":500824},{"artifact":1,"gen_end":656280,"gen_start":655840,"node":545,"role":"declaration","source":0,"src_end":501666,"src_start":501330},{"artifact":1,"gen_end":656716,"gen_start":656280,"node":546,"role":"declaration","source":0,"src_end":502061,"src_start":501668},{"artifact":1,"gen_end":660211,"gen_start":656716,"node":547,"role":"declaration","source":0,"src_end":504649,"src_start":502063},{"artifact":1,"gen_end":660995,"gen_start":660211,"node":548,"role":"declaration","source":0,"src_end":505199,"src_start":504651},{"artifact":1,"gen_end":661346,"gen_start":660995,"node":549,"role":"declaration","source":0,"src_end":505473,"src_start":505201},{"artifact":1,"gen_end":661896,"gen_start":661346,"node":550,"role":"declaration","source":0,"src_end":505990,"src_start":505475},{"artifact":1,"gen_end":665397,"gen_start":661896,"node":551,"role":"declaration","source":0,"src_end":508584,"src_start":505992},{"artifact":1,"gen_end":666193,"gen_start":665397,"node":552,"role":"declaration","source":0,"src_end":509146,"src_start":508586},{"artifact":1,"gen_end":666508,"gen_start":666193,"node":553,"role":"declaration","source":0,"src_end":509394,"src_start":509148},{"artifact":1,"gen_end":667070,"gen_start":666508,"node":554,"role":"declaration","source":0,"src_end":509923,"src_start":509396},{"artifact":1,"gen_end":670830,"gen_start":667070,"node":555,"role":"declaration","source":0,"src_end":512727,"src_start":509925},{"artifact":1,"gen_end":671614,"gen_start":670830,"node":556,"role":"declaration","source":0,"src_end":513277,"src_start":512729},{"artifact":1,"gen_end":672100,"gen_start":671614,"node":557,"role":"declaration","source":0,"src_end":513649,"src_start":513279},{"artifact":1,"gen_end":672625,"gen_start":672100,"node":558,"role":"declaration","source":0,"src_end":514107,"src_start":513651},{"artifact":1,"gen_end":676391,"gen_start":672625,"node":559,"role":"declaration","source":0,"src_end":516917,"src_start":514109},{"artifact":1,"gen_end":677187,"gen_start":676391,"node":560,"role":"declaration","source":0,"src_end":517479,"src_start":516919},{"artifact":1,"gen_end":677819,"gen_start":677187,"node":561,"role":"declaration","source":0,"src_end":517973,"src_start":517481},{"artifact":1,"gen_end":678356,"gen_start":677819,"node":562,"role":"declaration","source":0,"src_end":518443,"src_start":517975},{"artifact":1,"gen_end":680721,"gen_start":678356,"node":563,"role":"declaration","source":0,"src_end":520164,"src_start":518445},{"artifact":1,"gen_end":681459,"gen_start":680721,"node":564,"role":"declaration","source":0,"src_end":520674,"src_start":520166},{"artifact":1,"gen_end":681913,"gen_start":681459,"node":565,"role":"declaration","source":0,"src_end":521026,"src_start":520676},{"artifact":1,"gen_end":682361,"gen_start":681913,"node":566,"role":"declaration","source":0,"src_end":521433,"src_start":521028},{"artifact":1,"gen_end":696635,"gen_start":682361,"node":567,"role":"declaration","source":0,"src_end":532181,"src_start":521435},{"artifact":1,"gen_end":697423,"gen_start":696635,"node":568,"role":"declaration","source":0,"src_end":532741,"src_start":532183},{"artifact":1,"gen_end":698609,"gen_start":697423,"node":569,"role":"declaration","source":0,"src_end":533667,"src_start":532743},{"artifact":1,"gen_end":708673,"gen_start":698609,"node":570,"role":"declaration","source":0,"src_end":541388,"src_start":533669},{"artifact":1,"gen_end":709058,"gen_start":708673,"node":571,"role":"declaration","source":0,"src_end":541620,"src_start":541390},{"artifact":1,"gen_end":710239,"gen_start":709058,"node":572,"role":"declaration","source":0,"src_end":542588,"src_start":541622},{"artifact":1,"gen_end":711211,"gen_start":710239,"node":573,"role":"declaration","source":0,"src_end":543255,"src_start":542590},{"artifact":1,"gen_end":711598,"gen_start":711211,"node":574,"role":"declaration","source":0,"src_end":543489,"src_start":543257},{"artifact":1,"gen_end":711873,"gen_start":711598,"node":575,"role":"declaration","source":0,"src_end":543705,"src_start":543491},{"artifact":1,"gen_end":712844,"gen_start":711873,"node":576,"role":"declaration","source":0,"src_end":544371,"src_start":543707},{"artifact":1,"gen_end":713231,"gen_start":712844,"node":577,"role":"declaration","source":0,"src_end":544605,"src_start":544373},{"artifact":1,"gen_end":713506,"gen_start":713231,"node":578,"role":"declaration","source":0,"src_end":544821,"src_start":544607},{"artifact":1,"gen_end":714734,"gen_start":713506,"node":579,"role":"declaration","source":0,"src_end":545687,"src_start":544823},{"artifact":1,"gen_end":715127,"gen_start":714734,"node":580,"role":"declaration","source":0,"src_end":545927,"src_start":545689},{"artifact":1,"gen_end":715408,"gen_start":715127,"node":581,"role":"declaration","source":0,"src_end":546149,"src_start":545929},{"artifact":1,"gen_end":716295,"gen_start":715408,"node":582,"role":"declaration","source":0,"src_end":546745,"src_start":546151},{"artifact":1,"gen_end":716684,"gen_start":716295,"node":583,"role":"declaration","source":0,"src_end":546981,"src_start":546747},{"artifact":1,"gen_end":716961,"gen_start":716684,"node":584,"role":"declaration","source":0,"src_end":547199,"src_start":546983},{"artifact":1,"gen_end":734935,"gen_start":716961,"node":585,"role":"declaration","source":0,"src_end":560813,"src_start":547201},{"artifact":1,"gen_end":735310,"gen_start":734935,"node":586,"role":"declaration","source":0,"src_end":561035,"src_start":560815},{"artifact":1,"gen_end":736511,"gen_start":735310,"node":587,"role":"declaration","source":0,"src_end":562011,"src_start":561037},{"artifact":1,"gen_end":738745,"gen_start":736511,"node":588,"role":"declaration","source":0,"src_end":563607,"src_start":562013},{"artifact":1,"gen_end":739444,"gen_start":738745,"node":589,"role":"declaration","source":0,"src_end":564088,"src_start":563609},{"artifact":1,"gen_end":739765,"gen_start":739444,"node":590,"role":"declaration","source":0,"src_end":564340,"src_start":564090},{"artifact":1,"gen_end":741856,"gen_start":739765,"node":591,"role":"declaration","source":0,"src_end":565874,"src_start":564342},{"artifact":1,"gen_end":742473,"gen_start":741856,"node":592,"role":"declaration","source":0,"src_end":566291,"src_start":565876},{"artifact":1,"gen_end":742952,"gen_start":742473,"node":593,"role":"declaration","source":0,"src_end":566665,"src_start":566293},{"artifact":1,"gen_end":745886,"gen_start":742952,"node":594,"role":"declaration","source":0,"src_end":568802,"src_start":566667},{"artifact":1,"gen_end":746544,"gen_start":745886,"node":595,"role":"declaration","source":0,"src_end":569256,"src_start":568804},{"artifact":1,"gen_end":746858,"gen_start":746544,"node":596,"role":"declaration","source":0,"src_end":569501,"src_start":569258},{"artifact":1,"gen_end":747237,"gen_start":746858,"node":597,"role":"declaration","source":0,"src_end":569828,"src_start":569503},{"artifact":1,"gen_end":750177,"gen_start":747237,"node":598,"role":"declaration","source":0,"src_end":571971,"src_start":569830},{"artifact":1,"gen_end":750847,"gen_start":750177,"node":599,"role":"declaration","source":0,"src_end":572437,"src_start":571973},{"artifact":1,"gen_end":751174,"gen_start":750847,"node":600,"role":"declaration","source":0,"src_end":572695,"src_start":572439},{"artifact":1,"gen_end":751565,"gen_start":751174,"node":601,"role":"declaration","source":0,"src_end":573034,"src_start":572697},{"artifact":1,"gen_end":756428,"gen_start":751565,"node":602,"role":"declaration","source":0,"src_end":576645,"src_start":573036},{"artifact":1,"gen_end":757274,"gen_start":756428,"node":603,"role":"declaration","source":0,"src_end":577248,"src_start":576647},{"artifact":1,"gen_end":757727,"gen_start":757274,"node":604,"role":"declaration","source":0,"src_end":577599,"src_start":577250},{"artifact":1,"gen_end":758229,"gen_start":757727,"node":605,"role":"declaration","source":0,"src_end":578043,"src_start":577601},{"artifact":1,"gen_end":761357,"gen_start":758229,"node":606,"role":"declaration","source":0,"src_end":580389,"src_start":578045},{"artifact":1,"gen_end":761961,"gen_start":761357,"node":607,"role":"declaration","source":0,"src_end":580795,"src_start":580391},{"artifact":1,"gen_end":762266,"gen_start":761961,"node":608,"role":"declaration","source":0,"src_end":581031,"src_start":580797},{"artifact":1,"gen_end":762730,"gen_start":762266,"node":609,"role":"declaration","source":0,"src_end":581427,"src_start":581033},{"artifact":1,"gen_end":766356,"gen_start":762730,"node":610,"role":"declaration","source":0,"src_end":584119,"src_start":581429},{"artifact":1,"gen_end":766935,"gen_start":766356,"node":611,"role":"declaration","source":0,"src_end":584506,"src_start":584121},{"artifact":1,"gen_end":767396,"gen_start":766935,"node":612,"role":"declaration","source":0,"src_end":584865,"src_start":584508},{"artifact":1,"gen_end":767875,"gen_start":767396,"node":613,"role":"declaration","source":0,"src_end":585264,"src_start":584867},{"artifact":1,"gen_end":771488,"gen_start":767875,"node":614,"role":"declaration","source":0,"src_end":587943,"src_start":585266},{"artifact":1,"gen_end":772128,"gen_start":771488,"node":615,"role":"declaration","source":0,"src_end":588385,"src_start":587945},{"artifact":1,"gen_end":772650,"gen_start":772128,"node":616,"role":"declaration","source":0,"src_end":588799,"src_start":588387},{"artifact":1,"gen_end":773145,"gen_start":772650,"node":617,"role":"declaration","source":0,"src_end":589214,"src_start":588801},{"artifact":1,"gen_end":777263,"gen_start":773145,"node":618,"role":"declaration","source":0,"src_end":592302,"src_start":589216},{"artifact":1,"gen_end":777907,"gen_start":777263,"node":619,"role":"declaration","source":0,"src_end":592748,"src_start":592304},{"artifact":1,"gen_end":778433,"gen_start":777907,"node":620,"role":"declaration","source":0,"src_end":593166,"src_start":592750},{"artifact":1,"gen_end":778937,"gen_start":778433,"node":621,"role":"declaration","source":0,"src_end":593590,"src_start":593168},{"artifact":1,"gen_end":782550,"gen_start":778937,"node":622,"role":"declaration","source":0,"src_end":596269,"src_start":593592},{"artifact":1,"gen_end":783210,"gen_start":782550,"node":623,"role":"declaration","source":0,"src_end":596725,"src_start":596271},{"artifact":1,"gen_end":783752,"gen_start":783210,"node":624,"role":"declaration","source":0,"src_end":597153,"src_start":596727},{"artifact":1,"gen_end":784224,"gen_start":783752,"node":625,"role":"declaration","source":0,"src_end":597545,"src_start":597155},{"artifact":1,"gen_end":788753,"gen_start":784224,"node":626,"role":"declaration","source":0,"src_end":600948,"src_start":597547},{"artifact":1,"gen_end":789639,"gen_start":788753,"node":627,"role":"declaration","source":0,"src_end":601582,"src_start":600950},{"artifact":1,"gen_end":790407,"gen_start":789639,"node":628,"role":"declaration","source":0,"src_end":602188,"src_start":601584},{"artifact":1,"gen_end":790965,"gen_start":790407,"node":629,"role":"declaration","source":0,"src_end":602645,"src_start":602190},{"artifact":1,"gen_end":794617,"gen_start":790965,"node":630,"role":"declaration","source":0,"src_end":605363,"src_start":602647},{"artifact":1,"gen_end":795259,"gen_start":794617,"node":631,"role":"declaration","source":0,"src_end":605801,"src_start":605365},{"artifact":1,"gen_end":795783,"gen_start":795259,"node":632,"role":"declaration","source":0,"src_end":606211,"src_start":605803},{"artifact":1,"gen_end":796283,"gen_start":795783,"node":633,"role":"declaration","source":0,"src_end":606625,"src_start":606213},{"artifact":1,"gen_end":801148,"gen_start":796283,"node":634,"role":"declaration","source":0,"src_end":610238,"src_start":606627},{"artifact":1,"gen_end":801998,"gen_start":801148,"node":635,"role":"declaration","source":0,"src_end":610845,"src_start":610240},{"artifact":1,"gen_end":802409,"gen_start":801998,"node":636,"role":"declaration","source":0,"src_end":611160,"src_start":610847},{"artifact":1,"gen_end":802917,"gen_start":802409,"node":637,"role":"declaration","source":0,"src_end":611610,"src_start":611162},{"artifact":1,"gen_end":806029,"gen_start":802917,"node":638,"role":"declaration","source":0,"src_end":613902,"src_start":611612},{"artifact":1,"gen_end":806683,"gen_start":806029,"node":639,"role":"declaration","source":0,"src_end":614352,"src_start":613904},{"artifact":1,"gen_end":807127,"gen_start":806683,"node":640,"role":"declaration","source":0,"src_end":614694,"src_start":614354},{"artifact":1,"gen_end":807593,"gen_start":807127,"node":641,"role":"declaration","source":0,"src_end":615080,"src_start":614696},{"artifact":1,"gen_end":810711,"gen_start":807593,"node":642,"role":"declaration","source":0,"src_end":617378,"src_start":615082},{"artifact":1,"gen_end":811377,"gen_start":810711,"node":643,"role":"declaration","source":0,"src_end":617840,"src_start":617380},{"artifact":1,"gen_end":811879,"gen_start":811377,"node":644,"role":"declaration","source":0,"src_end":618234,"src_start":617842},{"artifact":1,"gen_end":812357,"gen_start":811879,"node":645,"role":"declaration","source":0,"src_end":618632,"src_start":618236},{"artifact":1,"gen_end":817188,"gen_start":812357,"node":646,"role":"declaration","source":0,"src_end":622247,"src_start":618634},{"artifact":1,"gen_end":818024,"gen_start":817188,"node":647,"role":"declaration","source":0,"src_end":622840,"src_start":622249},{"artifact":1,"gen_end":818605,"gen_start":818024,"node":648,"role":"declaration","source":0,"src_end":623301,"src_start":622842},{"artifact":1,"gen_end":819092,"gen_start":818605,"node":649,"role":"declaration","source":0,"src_end":623730,"src_start":623303},{"artifact":1,"gen_end":827983,"gen_start":819092,"node":650,"role":"declaration","source":0,"src_end":630646,"src_start":623732},{"artifact":1,"gen_end":828366,"gen_start":827983,"node":651,"role":"declaration","source":0,"src_end":630876,"src_start":630648},{"artifact":1,"gen_end":830219,"gen_start":828366,"node":652,"role":"declaration","source":0,"src_end":632082,"src_start":630878},{"artifact":1,"gen_end":830650,"gen_start":830219,"node":653,"role":"declaration","source":0,"src_end":632354,"src_start":632084},{"artifact":1,"gen_end":831225,"gen_start":830650,"node":654,"role":"declaration","source":0,"src_end":632730,"src_start":632356},{"artifact":1,"gen_end":832829,"gen_start":831225,"node":655,"role":"declaration","source":0,"src_end":633854,"src_start":632732},{"artifact":1,"gen_end":833246,"gen_start":832829,"node":656,"role":"declaration","source":0,"src_end":634112,"src_start":633856},{"artifact":1,"gen_end":833546,"gen_start":833246,"node":657,"role":"declaration","source":0,"src_end":634343,"src_start":634114},{"artifact":1,"gen_end":835159,"gen_start":833546,"node":658,"role":"declaration","source":0,"src_end":635476,"src_start":634345},{"artifact":1,"gen_end":835592,"gen_start":835159,"node":659,"role":"declaration","source":0,"src_end":635750,"src_start":635478},{"artifact":1,"gen_end":835864,"gen_start":835592,"node":660,"role":"declaration","source":0,"src_end":635965,"src_start":635752},{"artifact":1,"gen_end":841611,"gen_start":835864,"node":661,"role":"declaration","source":0,"src_end":640246,"src_start":635967},{"artifact":1,"gen_end":842040,"gen_start":841611,"node":662,"role":"declaration","source":0,"src_end":640516,"src_start":640248},{"artifact":1,"gen_end":842629,"gen_start":842040,"node":663,"role":"declaration","source":0,"src_end":640982,"src_start":640518},{"artifact":1,"gen_end":849600,"gen_start":842629,"node":664,"role":"declaration","source":0,"src_end":646140,"src_start":640984},{"artifact":1,"gen_end":850068,"gen_start":849600,"node":665,"role":"declaration","source":0,"src_end":646445,"src_start":646142},{"artifact":1,"gen_end":850493,"gen_start":850068,"node":666,"role":"declaration","source":0,"src_end":646779,"src_start":646447},{"artifact":1,"gen_end":858781,"gen_start":850493,"node":667,"role":"declaration","source":0,"src_end":653341,"src_start":646781},{"artifact":1,"gen_end":859206,"gen_start":858781,"node":668,"role":"declaration","source":0,"src_end":653607,"src_start":653343},{"artifact":1,"gen_end":859756,"gen_start":859206,"node":669,"role":"declaration","source":0,"src_end":654038,"src_start":653609},{"artifact":1,"gen_end":859771,"gen_start":859756,"node":335,"role":"declaration","source":0,"src_end":654074,"src_start":0}],"module":"TargetFixtures","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"},{"id":138,"kind":"semantic-declaration"},{"id":139,"kind":"semantic-declaration"},{"id":140,"kind":"semantic-declaration"},{"id":141,"kind":"semantic-declaration"},{"id":142,"kind":"semantic-declaration"},{"id":143,"kind":"semantic-declaration"},{"id":144,"kind":"semantic-declaration"},{"id":145,"kind":"semantic-declaration"},{"id":146,"kind":"semantic-declaration"},{"id":147,"kind":"semantic-declaration"},{"id":148,"kind":"semantic-declaration"},{"id":149,"kind":"semantic-declaration"},{"id":150,"kind":"semantic-declaration"},{"id":151,"kind":"semantic-declaration"},{"id":152,"kind":"semantic-declaration"},{"id":153,"kind":"semantic-declaration"},{"id":154,"kind":"semantic-declaration"},{"id":155,"kind":"semantic-declaration"},{"id":156,"kind":"semantic-declaration"},{"id":157,"kind":"semantic-declaration"},{"id":158,"kind":"semantic-declaration"},{"id":159,"kind":"semantic-declaration"},{"id":160,"kind":"semantic-declaration"},{"id":161,"kind":"semantic-declaration"},{"id":162,"kind":"semantic-declaration"},{"id":163,"kind":"semantic-declaration"},{"id":164,"kind":"semantic-declaration"},{"id":165,"kind":"semantic-declaration"},{"id":166,"kind":"semantic-declaration"},{"id":167,"kind":"semantic-declaration"},{"id":168,"kind":"semantic-declaration"},{"id":169,"kind":"semantic-declaration"},{"id":170,"kind":"semantic-declaration"},{"id":171,"kind":"semantic-declaration"},{"id":172,"kind":"semantic-declaration"},{"id":173,"kind":"semantic-declaration"},{"id":174,"kind":"semantic-declaration"},{"id":175,"kind":"semantic-declaration"},{"id":176,"kind":"semantic-declaration"},{"id":177,"kind":"semantic-declaration"},{"id":178,"kind":"semantic-declaration"},{"id":179,"kind":"semantic-declaration"},{"id":180,"kind":"semantic-declaration"},{"id":181,"kind":"semantic-declaration"},{"id":182,"kind":"semantic-declaration"},{"id":183,"kind":"semantic-declaration"},{"id":184,"kind":"semantic-declaration"},{"id":185,"kind":"semantic-declaration"},{"id":186,"kind":"semantic-declaration"},{"id":187,"kind":"semantic-declaration"},{"id":188,"kind":"semantic-declaration"},{"id":189,"kind":"semantic-declaration"},{"id":190,"kind":"semantic-declaration"},{"id":191,"kind":"semantic-declaration"},{"id":192,"kind":"semantic-declaration"},{"id":193,"kind":"semantic-declaration"},{"id":194,"kind":"semantic-declaration"},{"id":195,"kind":"semantic-declaration"},{"id":196,"kind":"semantic-declaration"},{"id":197,"kind":"semantic-declaration"},{"id":198,"kind":"semantic-declaration"},{"id":199,"kind":"semantic-declaration"},{"id":200,"kind":"semantic-declaration"},{"id":201,"kind":"semantic-declaration"},{"id":202,"kind":"semantic-declaration"},{"id":203,"kind":"semantic-declaration"},{"id":204,"kind":"semantic-declaration"},{"id":205,"kind":"semantic-declaration"},{"id":206,"kind":"semantic-declaration"},{"id":207,"kind":"semantic-declaration"},{"id":208,"kind":"semantic-declaration"},{"id":209,"kind":"semantic-declaration"},{"id":210,"kind":"semantic-declaration"},{"id":211,"kind":"semantic-declaration"},{"id":212,"kind":"semantic-declaration"},{"id":213,"kind":"semantic-declaration"},{"id":214,"kind":"semantic-declaration"},{"id":215,"kind":"semantic-declaration"},{"id":216,"kind":"semantic-declaration"},{"id":217,"kind":"semantic-declaration"},{"id":218,"kind":"semantic-declaration"},{"id":219,"kind":"semantic-declaration"},{"id":220,"kind":"semantic-declaration"},{"id":221,"kind":"semantic-declaration"},{"id":222,"kind":"semantic-declaration"},{"id":223,"kind":"semantic-declaration"},{"id":224,"kind":"semantic-declaration"},{"id":225,"kind":"semantic-declaration"},{"id":226,"kind":"semantic-declaration"},{"id":227,"kind":"semantic-declaration"},{"id":228,"kind":"semantic-declaration"},{"id":229,"kind":"semantic-declaration"},{"id":230,"kind":"semantic-declaration"},{"id":231,"kind":"semantic-declaration"},{"id":232,"kind":"semantic-declaration"},{"id":233,"kind":"semantic-declaration"},{"id":234,"kind":"semantic-declaration"},{"id":235,"kind":"semantic-declaration"},{"id":236,"kind":"semantic-declaration"},{"id":237,"kind":"semantic-declaration"},{"id":238,"kind":"semantic-declaration"},{"id":239,"kind":"semantic-declaration"},{"id":240,"kind":"semantic-declaration"},{"id":241,"kind":"semantic-declaration"},{"id":242,"kind":"semantic-declaration"},{"id":243,"kind":"semantic-declaration"},{"id":244,"kind":"semantic-declaration"},{"id":245,"kind":"semantic-declaration"},{"id":246,"kind":"semantic-declaration"},{"id":247,"kind":"semantic-declaration"},{"id":248,"kind":"semantic-declaration"},{"id":249,"kind":"semantic-declaration"},{"id":250,"kind":"semantic-declaration"},{"id":251,"kind":"semantic-declaration"},{"id":252,"kind":"semantic-declaration"},{"id":253,"kind":"semantic-declaration"},{"id":254,"kind":"semantic-declaration"},{"id":255,"kind":"semantic-declaration"},{"id":256,"kind":"semantic-declaration"},{"id":257,"kind":"semantic-declaration"},{"id":258,"kind":"semantic-declaration"},{"id":259,"kind":"semantic-declaration"},{"id":260,"kind":"semantic-declaration"},{"id":261,"kind":"semantic-declaration"},{"id":262,"kind":"semantic-declaration"},{"id":263,"kind":"semantic-declaration"},{"id":264,"kind":"semantic-declaration"},{"id":265,"kind":"semantic-declaration"},{"id":266,"kind":"semantic-declaration"},{"id":267,"kind":"semantic-declaration"},{"id":268,"kind":"semantic-declaration"},{"id":269,"kind":"semantic-declaration"},{"id":270,"kind":"semantic-declaration"},{"id":271,"kind":"semantic-declaration"},{"id":272,"kind":"semantic-declaration"},{"id":273,"kind":"semantic-declaration"},{"id":274,"kind":"semantic-declaration"},{"id":275,"kind":"semantic-declaration"},{"id":276,"kind":"semantic-declaration"},{"id":277,"kind":"semantic-declaration"},{"id":278,"kind":"semantic-declaration"},{"id":279,"kind":"semantic-declaration"},{"id":280,"kind":"semantic-declaration"},{"id":281,"kind":"semantic-declaration"},{"id":282,"kind":"semantic-declaration"},{"id":283,"kind":"semantic-declaration"},{"id":284,"kind":"semantic-declaration"},{"id":285,"kind":"semantic-declaration"},{"id":286,"kind":"semantic-declaration"},{"id":287,"kind":"semantic-declaration"},{"id":288,"kind":"semantic-declaration"},{"id":289,"kind":"semantic-declaration"},{"id":290,"kind":"semantic-declaration"},{"id":291,"kind":"semantic-declaration"},{"id":292,"kind":"semantic-declaration"},{"id":293,"kind":"semantic-declaration"},{"id":294,"kind":"semantic-declaration"},{"id":295,"kind":"semantic-declaration"},{"id":296,"kind":"semantic-declaration"},{"id":297,"kind":"semantic-declaration"},{"id":298,"kind":"semantic-declaration"},{"id":299,"kind":"semantic-declaration"},{"id":300,"kind":"semantic-declaration"},{"id":301,"kind":"semantic-declaration"},{"id":302,"kind":"semantic-declaration"},{"id":303,"kind":"semantic-declaration"},{"id":304,"kind":"semantic-declaration"},{"id":305,"kind":"semantic-declaration"},{"id":306,"kind":"semantic-declaration"},{"id":307,"kind":"semantic-declaration"},{"id":308,"kind":"semantic-declaration"},{"id":309,"kind":"semantic-declaration"},{"id":310,"kind":"semantic-declaration"},{"id":311,"kind":"semantic-declaration"},{"id":312,"kind":"semantic-declaration"},{"id":313,"kind":"semantic-declaration"},{"id":314,"kind":"semantic-declaration"},{"id":315,"kind":"semantic-declaration"},{"id":316,"kind":"semantic-declaration"},{"id":317,"kind":"semantic-declaration"},{"id":318,"kind":"semantic-declaration"},{"id":319,"kind":"semantic-declaration"},{"id":320,"kind":"semantic-declaration"},{"id":321,"kind":"semantic-declaration"},{"id":322,"kind":"semantic-declaration"},{"id":323,"kind":"semantic-declaration"},{"id":324,"kind":"semantic-declaration"},{"id":325,"kind":"semantic-declaration"},{"id":326,"kind":"semantic-declaration"},{"id":327,"kind":"semantic-declaration"},{"id":328,"kind":"semantic-declaration"},{"id":329,"kind":"semantic-declaration"},{"id":330,"kind":"semantic-declaration"},{"id":331,"kind":"semantic-declaration"},{"id":332,"kind":"semantic-declaration"},{"id":333,"kind":"semantic-declaration"},{"id":334,"kind":"semantic-declaration"},{"id":335,"kind":"semantic-latex-module"},{"id":336,"kind":"semantic-declaration"},{"id":337,"kind":"semantic-declaration"},{"id":338,"kind":"semantic-declaration"},{"id":339,"kind":"semantic-declaration"},{"id":340,"kind":"semantic-declaration"},{"id":341,"kind":"semantic-declaration"},{"id":342,"kind":"semantic-declaration"},{"id":343,"kind":"semantic-declaration"},{"id":344,"kind":"semantic-declaration"},{"id":345,"kind":"semantic-declaration"},{"id":346,"kind":"semantic-declaration"},{"id":347,"kind":"semantic-declaration"},{"id":348,"kind":"semantic-declaration"},{"id":349,"kind":"semantic-declaration"},{"id":350,"kind":"semantic-declaration"},{"id":351,"kind":"semantic-declaration"},{"id":352,"kind":"semantic-declaration"},{"id":353,"kind":"semantic-declaration"},{"id":354,"kind":"semantic-declaration"},{"id":355,"kind":"semantic-declaration"},{"id":356,"kind":"semantic-declaration"},{"id":357,"kind":"semantic-declaration"},{"id":358,"kind":"semantic-declaration"},{"id":359,"kind":"semantic-declaration"},{"id":360,"kind":"semantic-declaration"},{"id":361,"kind":"semantic-declaration"},{"id":362,"kind":"semantic-declaration"},{"id":363,"kind":"semantic-declaration"},{"id":364,"kind":"semantic-declaration"},{"id":365,"kind":"semantic-declaration"},{"id":366,"kind":"semantic-declaration"},{"id":367,"kind":"semantic-declaration"},{"id":368,"kind":"semantic-declaration"},{"id":369,"kind":"semantic-declaration"},{"id":370,"kind":"semantic-declaration"},{"id":371,"kind":"semantic-declaration"},{"id":372,"kind":"semantic-declaration"},{"id":373,"kind":"semantic-declaration"},{"id":374,"kind":"semantic-declaration"},{"id":375,"kind":"semantic-declaration"},{"id":376,"kind":"semantic-declaration"},{"id":377,"kind":"semantic-declaration"},{"id":378,"kind":"semantic-declaration"},{"id":379,"kind":"semantic-declaration"},{"id":380,"kind":"semantic-declaration"},{"id":381,"kind":"semantic-declaration"},{"id":382,"kind":"semantic-declaration"},{"id":383,"kind":"semantic-declaration"},{"id":384,"kind":"semantic-declaration"},{"id":385,"kind":"semantic-declaration"},{"id":386,"kind":"semantic-declaration"},{"id":387,"kind":"semantic-declaration"},{"id":388,"kind":"semantic-declaration"},{"id":389,"kind":"semantic-declaration"},{"id":390,"kind":"semantic-declaration"},{"id":391,"kind":"semantic-declaration"},{"id":392,"kind":"semantic-declaration"},{"id":393,"kind":"semantic-declaration"},{"id":394,"kind":"semantic-declaration"},{"id":395,"kind":"semantic-declaration"},{"id":396,"kind":"semantic-declaration"},{"id":397,"kind":"semantic-declaration"},{"id":398,"kind":"semantic-declaration"},{"id":399,"kind":"semantic-declaration"},{"id":400,"kind":"semantic-declaration"},{"id":401,"kind":"semantic-declaration"},{"id":402,"kind":"semantic-declaration"},{"id":403,"kind":"semantic-declaration"},{"id":404,"kind":"semantic-declaration"},{"id":405,"kind":"semantic-declaration"},{"id":406,"kind":"semantic-declaration"},{"id":407,"kind":"semantic-declaration"},{"id":408,"kind":"semantic-declaration"},{"id":409,"kind":"semantic-declaration"},{"id":410,"kind":"semantic-declaration"},{"id":411,"kind":"semantic-declaration"},{"id":412,"kind":"semantic-declaration"},{"id":413,"kind":"semantic-declaration"},{"id":414,"kind":"semantic-declaration"},{"id":415,"kind":"semantic-declaration"},{"id":416,"kind":"semantic-declaration"},{"id":417,"kind":"semantic-declaration"},{"id":418,"kind":"semantic-declaration"},{"id":419,"kind":"semantic-declaration"},{"id":420,"kind":"semantic-declaration"},{"id":421,"kind":"semantic-declaration"},{"id":422,"kind":"semantic-declaration"},{"id":423,"kind":"semantic-declaration"},{"id":424,"kind":"semantic-declaration"},{"id":425,"kind":"semantic-declaration"},{"id":426,"kind":"semantic-declaration"},{"id":427,"kind":"semantic-declaration"},{"id":428,"kind":"semantic-declaration"},{"id":429,"kind":"semantic-declaration"},{"id":430,"kind":"semantic-declaration"},{"id":431,"kind":"semantic-declaration"},{"id":432,"kind":"semantic-declaration"},{"id":433,"kind":"semantic-declaration"},{"id":434,"kind":"semantic-declaration"},{"id":435,"kind":"semantic-declaration"},{"id":436,"kind":"semantic-declaration"},{"id":437,"kind":"semantic-declaration"},{"id":438,"kind":"semantic-declaration"},{"id":439,"kind":"semantic-declaration"},{"id":440,"kind":"semantic-declaration"},{"id":441,"kind":"semantic-declaration"},{"id":442,"kind":"semantic-declaration"},{"id":443,"kind":"semantic-declaration"},{"id":444,"kind":"semantic-declaration"},{"id":445,"kind":"semantic-declaration"},{"id":446,"kind":"semantic-declaration"},{"id":447,"kind":"semantic-declaration"},{"id":448,"kind":"semantic-declaration"},{"id":449,"kind":"semantic-declaration"},{"id":450,"kind":"semantic-declaration"},{"id":451,"kind":"semantic-declaration"},{"id":452,"kind":"semantic-declaration"},{"id":453,"kind":"semantic-declaration"},{"id":454,"kind":"semantic-declaration"},{"id":455,"kind":"semantic-declaration"},{"id":456,"kind":"semantic-declaration"},{"id":457,"kind":"semantic-declaration"},{"id":458,"kind":"semantic-declaration"},{"id":459,"kind":"semantic-declaration"},{"id":460,"kind":"semantic-declaration"},{"id":461,"kind":"semantic-declaration"},{"id":462,"kind":"semantic-declaration"},{"id":463,"kind":"semantic-declaration"},{"id":464,"kind":"semantic-declaration"},{"id":465,"kind":"semantic-declaration"},{"id":466,"kind":"semantic-declaration"},{"id":467,"kind":"semantic-declaration"},{"id":468,"kind":"semantic-declaration"},{"id":469,"kind":"semantic-declaration"},{"id":470,"kind":"semantic-declaration"},{"id":471,"kind":"semantic-declaration"},{"id":472,"kind":"semantic-declaration"},{"id":473,"kind":"semantic-declaration"},{"id":474,"kind":"semantic-declaration"},{"id":475,"kind":"semantic-declaration"},{"id":476,"kind":"semantic-declaration"},{"id":477,"kind":"semantic-declaration"},{"id":478,"kind":"semantic-declaration"},{"id":479,"kind":"semantic-declaration"},{"id":480,"kind":"semantic-declaration"},{"id":481,"kind":"semantic-declaration"},{"id":482,"kind":"semantic-declaration"},{"id":483,"kind":"semantic-declaration"},{"id":484,"kind":"semantic-declaration"},{"id":485,"kind":"semantic-declaration"},{"id":486,"kind":"semantic-declaration"},{"id":487,"kind":"semantic-declaration"},{"id":488,"kind":"semantic-declaration"},{"id":489,"kind":"semantic-declaration"},{"id":490,"kind":"semantic-declaration"},{"id":491,"kind":"semantic-declaration"},{"id":492,"kind":"semantic-declaration"},{"id":493,"kind":"semantic-declaration"},{"id":494,"kind":"semantic-declaration"},{"id":495,"kind":"semantic-declaration"},{"id":496,"kind":"semantic-declaration"},{"id":497,"kind":"semantic-declaration"},{"id":498,"kind":"semantic-declaration"},{"id":499,"kind":"semantic-declaration"},{"id":500,"kind":"semantic-declaration"},{"id":501,"kind":"semantic-declaration"},{"id":502,"kind":"semantic-declaration"},{"id":503,"kind":"semantic-declaration"},{"id":504,"kind":"semantic-declaration"},{"id":505,"kind":"semantic-declaration"},{"id":506,"kind":"semantic-declaration"},{"id":507,"kind":"semantic-declaration"},{"id":508,"kind":"semantic-declaration"},{"id":509,"kind":"semantic-declaration"},{"id":510,"kind":"semantic-declaration"},{"id":511,"kind":"semantic-declaration"},{"id":512,"kind":"semantic-declaration"},{"id":513,"kind":"semantic-declaration"},{"id":514,"kind":"semantic-declaration"},{"id":515,"kind":"semantic-declaration"},{"id":516,"kind":"semantic-declaration"},{"id":517,"kind":"semantic-declaration"},{"id":518,"kind":"semantic-declaration"},{"id":519,"kind":"semantic-declaration"},{"id":520,"kind":"semantic-declaration"},{"id":521,"kind":"semantic-declaration"},{"id":522,"kind":"semantic-declaration"},{"id":523,"kind":"semantic-declaration"},{"id":524,"kind":"semantic-declaration"},{"id":525,"kind":"semantic-declaration"},{"id":526,"kind":"semantic-declaration"},{"id":527,"kind":"semantic-declaration"},{"id":528,"kind":"semantic-declaration"},{"id":529,"kind":"semantic-declaration"},{"id":530,"kind":"semantic-declaration"},{"id":531,"kind":"semantic-declaration"},{"id":532,"kind":"semantic-declaration"},{"id":533,"kind":"semantic-declaration"},{"id":534,"kind":"semantic-declaration"},{"id":535,"kind":"semantic-declaration"},{"id":536,"kind":"semantic-declaration"},{"id":537,"kind":"semantic-declaration"},{"id":538,"kind":"semantic-declaration"},{"id":539,"kind":"semantic-declaration"},{"id":540,"kind":"semantic-declaration"},{"id":541,"kind":"semantic-declaration"},{"id":542,"kind":"semantic-declaration"},{"id":543,"kind":"semantic-declaration"},{"id":544,"kind":"semantic-declaration"},{"id":545,"kind":"semantic-declaration"},{"id":546,"kind":"semantic-declaration"},{"id":547,"kind":"semantic-declaration"},{"id":548,"kind":"semantic-declaration"},{"id":549,"kind":"semantic-declaration"},{"id":550,"kind":"semantic-declaration"},{"id":551,"kind":"semantic-declaration"},{"id":552,"kind":"semantic-declaration"},{"id":553,"kind":"semantic-declaration"},{"id":554,"kind":"semantic-declaration"},{"id":555,"kind":"semantic-declaration"},{"id":556,"kind":"semantic-declaration"},{"id":557,"kind":"semantic-declaration"},{"id":558,"kind":"semantic-declaration"},{"id":559,"kind":"semantic-declaration"},{"id":560,"kind":"semantic-declaration"},{"id":561,"kind":"semantic-declaration"},{"id":562,"kind":"semantic-declaration"},{"id":563,"kind":"semantic-declaration"},{"id":564,"kind":"semantic-declaration"},{"id":565,"kind":"semantic-declaration"},{"id":566,"kind":"semantic-declaration"},{"id":567,"kind":"semantic-declaration"},{"id":568,"kind":"semantic-declaration"},{"id":569,"kind":"semantic-declaration"},{"id":570,"kind":"semantic-declaration"},{"id":571,"kind":"semantic-declaration"},{"id":572,"kind":"semantic-declaration"},{"id":573,"kind":"semantic-declaration"},{"id":574,"kind":"semantic-declaration"},{"id":575,"kind":"semantic-declaration"},{"id":576,"kind":"semantic-declaration"},{"id":577,"kind":"semantic-declaration"},{"id":578,"kind":"semantic-declaration"},{"id":579,"kind":"semantic-declaration"},{"id":580,"kind":"semantic-declaration"},{"id":581,"kind":"semantic-declaration"},{"id":582,"kind":"semantic-declaration"},{"id":583,"kind":"semantic-declaration"},{"id":584,"kind":"semantic-declaration"},{"id":585,"kind":"semantic-declaration"},{"id":586,"kind":"semantic-declaration"},{"id":587,"kind":"semantic-declaration"},{"id":588,"kind":"semantic-declaration"},{"id":589,"kind":"semantic-declaration"},{"id":590,"kind":"semantic-declaration"},{"id":591,"kind":"semantic-declaration"},{"id":592,"kind":"semantic-declaration"},{"id":593,"kind":"semantic-declaration"},{"id":594,"kind":"semantic-declaration"},{"id":595,"kind":"semantic-declaration"},{"id":596,"kind":"semantic-declaration"},{"id":597,"kind":"semantic-declaration"},{"id":598,"kind":"semantic-declaration"},{"id":599,"kind":"semantic-declaration"},{"id":600,"kind":"semantic-declaration"},{"id":601,"kind":"semantic-declaration"},{"id":602,"kind":"semantic-declaration"},{"id":603,"kind":"semantic-declaration"},{"id":604,"kind":"semantic-declaration"},{"id":605,"kind":"semantic-declaration"},{"id":606,"kind":"semantic-declaration"},{"id":607,"kind":"semantic-declaration"},{"id":608,"kind":"semantic-declaration"},{"id":609,"kind":"semantic-declaration"},{"id":610,"kind":"semantic-declaration"},{"id":611,"kind":"semantic-declaration"},{"id":612,"kind":"semantic-declaration"},{"id":613,"kind":"semantic-declaration"},{"id":614,"kind":"semantic-declaration"},{"id":615,"kind":"semantic-declaration"},{"id":616,"kind":"semantic-declaration"},{"id":617,"kind":"semantic-declaration"},{"id":618,"kind":"semantic-declaration"},{"id":619,"kind":"semantic-declaration"},{"id":620,"kind":"semantic-declaration"},{"id":621,"kind":"semantic-declaration"},{"id":622,"kind":"semantic-declaration"},{"id":623,"kind":"semantic-declaration"},{"id":624,"kind":"semantic-declaration"},{"id":625,"kind":"semantic-declaration"},{"id":626,"kind":"semantic-declaration"},{"id":627,"kind":"semantic-declaration"},{"id":628,"kind":"semantic-declaration"},{"id":629,"kind":"semantic-declaration"},{"id":630,"kind":"semantic-declaration"},{"id":631,"kind":"semantic-declaration"},{"id":632,"kind":"semantic-declaration"},{"id":633,"kind":"semantic-declaration"},{"id":634,"kind":"semantic-declaration"},{"id":635,"kind":"semantic-declaration"},{"id":636,"kind":"semantic-declaration"},{"id":637,"kind":"semantic-declaration"},{"id":638,"kind":"semantic-declaration"},{"id":639,"kind":"semantic-declaration"},{"id":640,"kind":"semantic-declaration"},{"id":641,"kind":"semantic-declaration"},{"id":642,"kind":"semantic-declaration"},{"id":643,"kind":"semantic-declaration"},{"id":644,"kind":"semantic-declaration"},{"id":645,"kind":"semantic-declaration"},{"id":646,"kind":"semantic-declaration"},{"id":647,"kind":"semantic-declaration"},{"id":648,"kind":"semantic-declaration"},{"id":649,"kind":"semantic-declaration"},{"id":650,"kind":"semantic-declaration"},{"id":651,"kind":"semantic-declaration"},{"id":652,"kind":"semantic-declaration"},{"id":653,"kind":"semantic-declaration"},{"id":654,"kind":"semantic-declaration"},{"id":655,"kind":"semantic-declaration"},{"id":656,"kind":"semantic-declaration"},{"id":657,"kind":"semantic-declaration"},{"id":658,"kind":"semantic-declaration"},{"id":659,"kind":"semantic-declaration"},{"id":660,"kind":"semantic-declaration"},{"id":661,"kind":"semantic-declaration"},{"id":662,"kind":"semantic-declaration"},{"id":663,"kind":"semantic-declaration"},{"id":664,"kind":"semantic-declaration"},{"id":665,"kind":"semantic-declaration"},{"id":666,"kind":"semantic-declaration"},{"id":667,"kind":"semantic-declaration"},{"id":668,"kind":"semantic-declaration"},{"id":669,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/TargetFixtures.lex.tex","sha256":"d746739ea3e78234f7a68280dc068d39b84f4064298a37383a8dc645bc188c27"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/TargetOracle.map.json b/compiler/expected/build/maps/LexLeanTarget/TargetOracle.map.json index f615c05c0..d4fc0dea2 100644 --- a/compiler/expected/build/maps/LexLeanTarget/TargetOracle.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/TargetOracle.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetOracle.tex"}],"mappings":[{"artifact":0,"gen_end":250,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":0,"gen_end":506,"gen_start":250,"node":1,"role":"declaration","source":0,"src_end":441,"src_start":149},{"artifact":0,"gen_end":762,"gen_start":506,"node":2,"role":"declaration","source":0,"src_end":735,"src_start":443},{"artifact":0,"gen_end":1016,"gen_start":762,"node":3,"role":"declaration","source":0,"src_end":1027,"src_start":737},{"artifact":0,"gen_end":1276,"gen_start":1016,"node":4,"role":"declaration","source":0,"src_end":1325,"src_start":1029},{"artifact":0,"gen_end":1544,"gen_start":1276,"node":5,"role":"declaration","source":0,"src_end":1631,"src_start":1327},{"artifact":0,"gen_end":1927,"gen_start":1544,"node":6,"role":"declaration","source":0,"src_end":2036,"src_start":1633},{"artifact":0,"gen_end":2323,"gen_start":1927,"node":7,"role":"declaration","source":0,"src_end":2454,"src_start":2038},{"artifact":0,"gen_end":2355,"gen_start":2323,"node":0,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":8,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":1,"gen_end":587,"gen_start":134,"node":9,"role":"declaration","source":0,"src_end":441,"src_start":149},{"artifact":1,"gen_end":1040,"gen_start":587,"node":10,"role":"declaration","source":0,"src_end":735,"src_start":443},{"artifact":1,"gen_end":1491,"gen_start":1040,"node":11,"role":"declaration","source":0,"src_end":1027,"src_start":737},{"artifact":1,"gen_end":1948,"gen_start":1491,"node":12,"role":"declaration","source":0,"src_end":1325,"src_start":1029},{"artifact":1,"gen_end":2413,"gen_start":1948,"node":13,"role":"declaration","source":0,"src_end":1631,"src_start":1327},{"artifact":1,"gen_end":2993,"gen_start":2413,"node":14,"role":"declaration","source":0,"src_end":2036,"src_start":1633},{"artifact":1,"gen_end":3586,"gen_start":2993,"node":15,"role":"declaration","source":0,"src_end":2454,"src_start":2038},{"artifact":1,"gen_end":3601,"gen_start":3586,"node":8,"role":"declaration","source":0,"src_end":2490,"src_start":0}],"module":"TargetOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-latex-module"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/TargetOracle.lex.tex","sha256":"e34fca12090e04d8a853d4edfc9ae8db46d09ec586f2820f25d69c8ab3a7fb2d"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetOracle.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetOracle.tex"}],"mappings":[{"artifact":0,"gen_end":250,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":0,"gen_end":506,"gen_start":250,"node":1,"role":"declaration","source":0,"src_end":441,"src_start":149},{"artifact":0,"gen_end":762,"gen_start":506,"node":2,"role":"declaration","source":0,"src_end":735,"src_start":443},{"artifact":0,"gen_end":1016,"gen_start":762,"node":3,"role":"declaration","source":0,"src_end":1027,"src_start":737},{"artifact":0,"gen_end":1276,"gen_start":1016,"node":4,"role":"declaration","source":0,"src_end":1325,"src_start":1029},{"artifact":0,"gen_end":1544,"gen_start":1276,"node":5,"role":"declaration","source":0,"src_end":1631,"src_start":1327},{"artifact":0,"gen_end":1927,"gen_start":1544,"node":6,"role":"declaration","source":0,"src_end":2036,"src_start":1633},{"artifact":0,"gen_end":2323,"gen_start":1927,"node":7,"role":"declaration","source":0,"src_end":2454,"src_start":2038},{"artifact":0,"gen_end":2355,"gen_start":2323,"node":0,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":8,"role":"declaration","source":0,"src_end":2490,"src_start":0},{"artifact":1,"gen_end":587,"gen_start":134,"node":9,"role":"declaration","source":0,"src_end":441,"src_start":149},{"artifact":1,"gen_end":1040,"gen_start":587,"node":10,"role":"declaration","source":0,"src_end":735,"src_start":443},{"artifact":1,"gen_end":1491,"gen_start":1040,"node":11,"role":"declaration","source":0,"src_end":1027,"src_start":737},{"artifact":1,"gen_end":1948,"gen_start":1491,"node":12,"role":"declaration","source":0,"src_end":1325,"src_start":1029},{"artifact":1,"gen_end":2413,"gen_start":1948,"node":13,"role":"declaration","source":0,"src_end":1631,"src_start":1327},{"artifact":1,"gen_end":2993,"gen_start":2413,"node":14,"role":"declaration","source":0,"src_end":2036,"src_start":1633},{"artifact":1,"gen_end":3586,"gen_start":2993,"node":15,"role":"declaration","source":0,"src_end":2454,"src_start":2038},{"artifact":1,"gen_end":3601,"gen_start":3586,"node":8,"role":"declaration","source":0,"src_end":2490,"src_start":0}],"module":"TargetOracle","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-latex-module"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/TargetOracle.lex.tex","sha256":"e34fca12090e04d8a853d4edfc9ae8db46d09ec586f2820f25d69c8ab3a7fb2d"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/TargetSemantics.map.json b/compiler/expected/build/maps/LexLeanTarget/TargetSemantics.map.json index 1c8e73c49..8867fbabb 100644 --- a/compiler/expected/build/maps/LexLeanTarget/TargetSemantics.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/TargetSemantics.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetSemantics.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetSemantics.tex"}],"mappings":[{"artifact":0,"gen_end":332,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":0,"gen_end":470,"gen_start":332,"node":1,"role":"declaration","source":0,"src_end":401,"src_start":152},{"artifact":0,"gen_end":617,"gen_start":470,"node":2,"role":"declaration","source":0,"src_end":661,"src_start":403},{"artifact":0,"gen_end":928,"gen_start":617,"node":3,"role":"declaration","source":0,"src_end":1035,"src_start":663},{"artifact":0,"gen_end":1249,"gen_start":928,"node":4,"role":"declaration","source":0,"src_end":1450,"src_start":1037},{"artifact":0,"gen_end":1504,"gen_start":1249,"node":5,"role":"declaration","source":0,"src_end":1751,"src_start":1452},{"artifact":0,"gen_end":2065,"gen_start":1504,"node":6,"role":"declaration","source":0,"src_end":2459,"src_start":1753},{"artifact":0,"gen_end":2269,"gen_start":2065,"node":7,"role":"declaration","source":0,"src_end":2685,"src_start":2461},{"artifact":0,"gen_end":2523,"gen_start":2269,"node":8,"role":"declaration","source":0,"src_end":3001,"src_start":2687},{"artifact":0,"gen_end":2999,"gen_start":2523,"node":9,"role":"declaration","source":0,"src_end":3390,"src_start":3003},{"artifact":0,"gen_end":3768,"gen_start":2999,"node":10,"role":"declaration","source":0,"src_end":4053,"src_start":3392},{"artifact":0,"gen_end":4168,"gen_start":3768,"node":11,"role":"declaration","source":0,"src_end":4462,"src_start":4055},{"artifact":0,"gen_end":4504,"gen_start":4168,"node":12,"role":"declaration","source":0,"src_end":4774,"src_start":4464},{"artifact":0,"gen_end":4840,"gen_start":4504,"node":13,"role":"declaration","source":0,"src_end":5086,"src_start":4776},{"artifact":0,"gen_end":5182,"gen_start":4840,"node":14,"role":"declaration","source":0,"src_end":5425,"src_start":5088},{"artifact":0,"gen_end":5536,"gen_start":5182,"node":15,"role":"declaration","source":0,"src_end":5806,"src_start":5427},{"artifact":0,"gen_end":5881,"gen_start":5536,"node":16,"role":"declaration","source":0,"src_end":6127,"src_start":5808},{"artifact":0,"gen_end":6232,"gen_start":5881,"node":17,"role":"declaration","source":0,"src_end":6454,"src_start":6129},{"artifact":0,"gen_end":6583,"gen_start":6232,"node":18,"role":"declaration","source":0,"src_end":6781,"src_start":6456},{"artifact":0,"gen_end":6934,"gen_start":6583,"node":19,"role":"declaration","source":0,"src_end":7108,"src_start":6783},{"artifact":0,"gen_end":7274,"gen_start":6934,"node":20,"role":"declaration","source":0,"src_end":7424,"src_start":7110},{"artifact":0,"gen_end":7620,"gen_start":7274,"node":21,"role":"declaration","source":0,"src_end":7746,"src_start":7426},{"artifact":0,"gen_end":7966,"gen_start":7620,"node":22,"role":"declaration","source":0,"src_end":8068,"src_start":7748},{"artifact":0,"gen_end":8312,"gen_start":7966,"node":23,"role":"declaration","source":0,"src_end":8390,"src_start":8070},{"artifact":0,"gen_end":29494,"gen_start":8312,"node":24,"role":"declaration","source":0,"src_end":39304,"src_start":8392},{"artifact":0,"gen_end":30463,"gen_start":29494,"node":25,"role":"declaration","source":0,"src_end":40479,"src_start":39306},{"artifact":0,"gen_end":32002,"gen_start":30463,"node":26,"role":"declaration","source":0,"src_end":41949,"src_start":40481},{"artifact":0,"gen_end":32217,"gen_start":32002,"node":27,"role":"declaration","source":0,"src_end":42245,"src_start":41951},{"artifact":0,"gen_end":32554,"gen_start":32217,"node":28,"role":"declaration","source":0,"src_end":42696,"src_start":42247},{"artifact":0,"gen_end":56303,"gen_start":32554,"node":29,"role":"declaration","source":0,"src_end":80179,"src_start":42698},{"artifact":0,"gen_end":62781,"gen_start":56303,"node":30,"role":"declaration","source":0,"src_end":87652,"src_start":80181},{"artifact":0,"gen_end":63045,"gen_start":62781,"node":31,"role":"declaration","source":0,"src_end":87954,"src_start":87654},{"artifact":0,"gen_end":64666,"gen_start":63045,"node":32,"role":"declaration","source":0,"src_end":90259,"src_start":87956},{"artifact":0,"gen_end":327076,"gen_start":64666,"node":33,"role":"declaration","source":0,"src_end":408473,"src_start":90261},{"artifact":0,"gen_end":340316,"gen_start":327076,"node":34,"role":"declaration","source":0,"src_end":423624,"src_start":408475},{"artifact":0,"gen_end":341450,"gen_start":340316,"node":35,"role":"declaration","source":0,"src_end":424840,"src_start":423626},{"artifact":0,"gen_end":342407,"gen_start":341450,"node":36,"role":"declaration","source":0,"src_end":425975,"src_start":424842},{"artifact":0,"gen_end":342979,"gen_start":342407,"node":37,"role":"declaration","source":0,"src_end":426603,"src_start":425977},{"artifact":0,"gen_end":343014,"gen_start":342979,"node":0,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":38,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":1,"gen_end":472,"gen_start":134,"node":39,"role":"declaration","source":0,"src_end":401,"src_start":152},{"artifact":1,"gen_end":819,"gen_start":472,"node":40,"role":"declaration","source":0,"src_end":661,"src_start":403},{"artifact":1,"gen_end":1312,"gen_start":819,"node":41,"role":"declaration","source":0,"src_end":1035,"src_start":663},{"artifact":1,"gen_end":1820,"gen_start":1312,"node":42,"role":"declaration","source":0,"src_end":1450,"src_start":1037},{"artifact":1,"gen_end":2262,"gen_start":1820,"node":43,"role":"declaration","source":0,"src_end":1751,"src_start":1452},{"artifact":1,"gen_end":2974,"gen_start":2262,"node":44,"role":"declaration","source":0,"src_end":2459,"src_start":1753},{"artifact":1,"gen_end":3360,"gen_start":2974,"node":45,"role":"declaration","source":0,"src_end":2685,"src_start":2461},{"artifact":1,"gen_end":3820,"gen_start":3360,"node":46,"role":"declaration","source":0,"src_end":3001,"src_start":2687},{"artifact":1,"gen_end":4493,"gen_start":3820,"node":47,"role":"declaration","source":0,"src_end":3390,"src_start":3003},{"artifact":1,"gen_end":5444,"gen_start":4493,"node":48,"role":"declaration","source":0,"src_end":4053,"src_start":3392},{"artifact":1,"gen_end":6028,"gen_start":5444,"node":49,"role":"declaration","source":0,"src_end":4462,"src_start":4055},{"artifact":1,"gen_end":6530,"gen_start":6028,"node":50,"role":"declaration","source":0,"src_end":4774,"src_start":4464},{"artifact":1,"gen_end":7032,"gen_start":6530,"node":51,"role":"declaration","source":0,"src_end":5086,"src_start":4776},{"artifact":1,"gen_end":7551,"gen_start":7032,"node":52,"role":"declaration","source":0,"src_end":5425,"src_start":5088},{"artifact":1,"gen_end":8112,"gen_start":7551,"node":53,"role":"declaration","source":0,"src_end":5806,"src_start":5427},{"artifact":1,"gen_end":8623,"gen_start":8112,"node":54,"role":"declaration","source":0,"src_end":6127,"src_start":5808},{"artifact":1,"gen_end":9140,"gen_start":8623,"node":55,"role":"declaration","source":0,"src_end":6454,"src_start":6129},{"artifact":1,"gen_end":9657,"gen_start":9140,"node":56,"role":"declaration","source":0,"src_end":6781,"src_start":6456},{"artifact":1,"gen_end":10174,"gen_start":9657,"node":57,"role":"declaration","source":0,"src_end":7108,"src_start":6783},{"artifact":1,"gen_end":10680,"gen_start":10174,"node":58,"role":"declaration","source":0,"src_end":7424,"src_start":7110},{"artifact":1,"gen_end":11192,"gen_start":10680,"node":59,"role":"declaration","source":0,"src_end":7746,"src_start":7426},{"artifact":1,"gen_end":11704,"gen_start":11192,"node":60,"role":"declaration","source":0,"src_end":8068,"src_start":7748},{"artifact":1,"gen_end":12216,"gen_start":11704,"node":61,"role":"declaration","source":0,"src_end":8390,"src_start":8070},{"artifact":1,"gen_end":33789,"gen_start":12216,"node":62,"role":"declaration","source":0,"src_end":39304,"src_start":8392},{"artifact":1,"gen_end":35022,"gen_start":33789,"node":63,"role":"declaration","source":0,"src_end":40479,"src_start":39306},{"artifact":1,"gen_end":36807,"gen_start":35022,"node":64,"role":"declaration","source":0,"src_end":41949,"src_start":40481},{"artifact":1,"gen_end":37299,"gen_start":36807,"node":65,"role":"declaration","source":0,"src_end":42245,"src_start":41951},{"artifact":1,"gen_end":37859,"gen_start":37299,"node":66,"role":"declaration","source":0,"src_end":42696,"src_start":42247},{"artifact":1,"gen_end":62160,"gen_start":37859,"node":67,"role":"declaration","source":0,"src_end":80179,"src_start":42698},{"artifact":1,"gen_end":68896,"gen_start":62160,"node":68,"role":"declaration","source":0,"src_end":87652,"src_start":80181},{"artifact":1,"gen_end":69357,"gen_start":68896,"node":69,"role":"declaration","source":0,"src_end":87954,"src_start":87654},{"artifact":1,"gen_end":71199,"gen_start":69357,"node":70,"role":"declaration","source":0,"src_end":90259,"src_start":87956},{"artifact":1,"gen_end":337147,"gen_start":71199,"node":71,"role":"declaration","source":0,"src_end":408473,"src_start":90261},{"artifact":1,"gen_end":350721,"gen_start":337147,"node":72,"role":"declaration","source":0,"src_end":423624,"src_start":408475},{"artifact":1,"gen_end":352052,"gen_start":350721,"node":73,"role":"declaration","source":0,"src_end":424840,"src_start":423626},{"artifact":1,"gen_end":353188,"gen_start":352052,"node":74,"role":"declaration","source":0,"src_end":425975,"src_start":424842},{"artifact":1,"gen_end":353983,"gen_start":353188,"node":75,"role":"declaration","source":0,"src_end":426603,"src_start":425977},{"artifact":1,"gen_end":353998,"gen_start":353983,"node":38,"role":"declaration","source":0,"src_end":426639,"src_start":0}],"module":"TargetSemantics","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-latex-module"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/TargetSemantics.lex.tex","sha256":"92551ec717ba14a68c53203b5ea1f68359902201116de69c2816668038eb4a60"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetSemantics.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetSemantics.tex"}],"mappings":[{"artifact":0,"gen_end":332,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":0,"gen_end":470,"gen_start":332,"node":1,"role":"declaration","source":0,"src_end":401,"src_start":152},{"artifact":0,"gen_end":617,"gen_start":470,"node":2,"role":"declaration","source":0,"src_end":661,"src_start":403},{"artifact":0,"gen_end":928,"gen_start":617,"node":3,"role":"declaration","source":0,"src_end":1035,"src_start":663},{"artifact":0,"gen_end":1249,"gen_start":928,"node":4,"role":"declaration","source":0,"src_end":1450,"src_start":1037},{"artifact":0,"gen_end":1504,"gen_start":1249,"node":5,"role":"declaration","source":0,"src_end":1751,"src_start":1452},{"artifact":0,"gen_end":2065,"gen_start":1504,"node":6,"role":"declaration","source":0,"src_end":2459,"src_start":1753},{"artifact":0,"gen_end":2269,"gen_start":2065,"node":7,"role":"declaration","source":0,"src_end":2685,"src_start":2461},{"artifact":0,"gen_end":2523,"gen_start":2269,"node":8,"role":"declaration","source":0,"src_end":3001,"src_start":2687},{"artifact":0,"gen_end":2999,"gen_start":2523,"node":9,"role":"declaration","source":0,"src_end":3390,"src_start":3003},{"artifact":0,"gen_end":3768,"gen_start":2999,"node":10,"role":"declaration","source":0,"src_end":4053,"src_start":3392},{"artifact":0,"gen_end":4168,"gen_start":3768,"node":11,"role":"declaration","source":0,"src_end":4462,"src_start":4055},{"artifact":0,"gen_end":4504,"gen_start":4168,"node":12,"role":"declaration","source":0,"src_end":4774,"src_start":4464},{"artifact":0,"gen_end":4840,"gen_start":4504,"node":13,"role":"declaration","source":0,"src_end":5086,"src_start":4776},{"artifact":0,"gen_end":5182,"gen_start":4840,"node":14,"role":"declaration","source":0,"src_end":5425,"src_start":5088},{"artifact":0,"gen_end":5536,"gen_start":5182,"node":15,"role":"declaration","source":0,"src_end":5806,"src_start":5427},{"artifact":0,"gen_end":5881,"gen_start":5536,"node":16,"role":"declaration","source":0,"src_end":6127,"src_start":5808},{"artifact":0,"gen_end":6232,"gen_start":5881,"node":17,"role":"declaration","source":0,"src_end":6454,"src_start":6129},{"artifact":0,"gen_end":6583,"gen_start":6232,"node":18,"role":"declaration","source":0,"src_end":6781,"src_start":6456},{"artifact":0,"gen_end":6934,"gen_start":6583,"node":19,"role":"declaration","source":0,"src_end":7108,"src_start":6783},{"artifact":0,"gen_end":7274,"gen_start":6934,"node":20,"role":"declaration","source":0,"src_end":7424,"src_start":7110},{"artifact":0,"gen_end":7620,"gen_start":7274,"node":21,"role":"declaration","source":0,"src_end":7746,"src_start":7426},{"artifact":0,"gen_end":7966,"gen_start":7620,"node":22,"role":"declaration","source":0,"src_end":8068,"src_start":7748},{"artifact":0,"gen_end":8312,"gen_start":7966,"node":23,"role":"declaration","source":0,"src_end":8390,"src_start":8070},{"artifact":0,"gen_end":29494,"gen_start":8312,"node":24,"role":"declaration","source":0,"src_end":39304,"src_start":8392},{"artifact":0,"gen_end":30463,"gen_start":29494,"node":25,"role":"declaration","source":0,"src_end":40479,"src_start":39306},{"artifact":0,"gen_end":32002,"gen_start":30463,"node":26,"role":"declaration","source":0,"src_end":41949,"src_start":40481},{"artifact":0,"gen_end":32217,"gen_start":32002,"node":27,"role":"declaration","source":0,"src_end":42245,"src_start":41951},{"artifact":0,"gen_end":32554,"gen_start":32217,"node":28,"role":"declaration","source":0,"src_end":42696,"src_start":42247},{"artifact":0,"gen_end":56303,"gen_start":32554,"node":29,"role":"declaration","source":0,"src_end":80179,"src_start":42698},{"artifact":0,"gen_end":62781,"gen_start":56303,"node":30,"role":"declaration","source":0,"src_end":87652,"src_start":80181},{"artifact":0,"gen_end":63045,"gen_start":62781,"node":31,"role":"declaration","source":0,"src_end":87954,"src_start":87654},{"artifact":0,"gen_end":64666,"gen_start":63045,"node":32,"role":"declaration","source":0,"src_end":90259,"src_start":87956},{"artifact":0,"gen_end":327076,"gen_start":64666,"node":33,"role":"declaration","source":0,"src_end":408473,"src_start":90261},{"artifact":0,"gen_end":340316,"gen_start":327076,"node":34,"role":"declaration","source":0,"src_end":423624,"src_start":408475},{"artifact":0,"gen_end":341450,"gen_start":340316,"node":35,"role":"declaration","source":0,"src_end":424840,"src_start":423626},{"artifact":0,"gen_end":342407,"gen_start":341450,"node":36,"role":"declaration","source":0,"src_end":425975,"src_start":424842},{"artifact":0,"gen_end":342979,"gen_start":342407,"node":37,"role":"declaration","source":0,"src_end":426603,"src_start":425977},{"artifact":0,"gen_end":343014,"gen_start":342979,"node":0,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":38,"role":"declaration","source":0,"src_end":426639,"src_start":0},{"artifact":1,"gen_end":472,"gen_start":134,"node":39,"role":"declaration","source":0,"src_end":401,"src_start":152},{"artifact":1,"gen_end":819,"gen_start":472,"node":40,"role":"declaration","source":0,"src_end":661,"src_start":403},{"artifact":1,"gen_end":1312,"gen_start":819,"node":41,"role":"declaration","source":0,"src_end":1035,"src_start":663},{"artifact":1,"gen_end":1820,"gen_start":1312,"node":42,"role":"declaration","source":0,"src_end":1450,"src_start":1037},{"artifact":1,"gen_end":2262,"gen_start":1820,"node":43,"role":"declaration","source":0,"src_end":1751,"src_start":1452},{"artifact":1,"gen_end":2974,"gen_start":2262,"node":44,"role":"declaration","source":0,"src_end":2459,"src_start":1753},{"artifact":1,"gen_end":3360,"gen_start":2974,"node":45,"role":"declaration","source":0,"src_end":2685,"src_start":2461},{"artifact":1,"gen_end":3820,"gen_start":3360,"node":46,"role":"declaration","source":0,"src_end":3001,"src_start":2687},{"artifact":1,"gen_end":4493,"gen_start":3820,"node":47,"role":"declaration","source":0,"src_end":3390,"src_start":3003},{"artifact":1,"gen_end":5444,"gen_start":4493,"node":48,"role":"declaration","source":0,"src_end":4053,"src_start":3392},{"artifact":1,"gen_end":6028,"gen_start":5444,"node":49,"role":"declaration","source":0,"src_end":4462,"src_start":4055},{"artifact":1,"gen_end":6530,"gen_start":6028,"node":50,"role":"declaration","source":0,"src_end":4774,"src_start":4464},{"artifact":1,"gen_end":7032,"gen_start":6530,"node":51,"role":"declaration","source":0,"src_end":5086,"src_start":4776},{"artifact":1,"gen_end":7551,"gen_start":7032,"node":52,"role":"declaration","source":0,"src_end":5425,"src_start":5088},{"artifact":1,"gen_end":8112,"gen_start":7551,"node":53,"role":"declaration","source":0,"src_end":5806,"src_start":5427},{"artifact":1,"gen_end":8623,"gen_start":8112,"node":54,"role":"declaration","source":0,"src_end":6127,"src_start":5808},{"artifact":1,"gen_end":9140,"gen_start":8623,"node":55,"role":"declaration","source":0,"src_end":6454,"src_start":6129},{"artifact":1,"gen_end":9657,"gen_start":9140,"node":56,"role":"declaration","source":0,"src_end":6781,"src_start":6456},{"artifact":1,"gen_end":10174,"gen_start":9657,"node":57,"role":"declaration","source":0,"src_end":7108,"src_start":6783},{"artifact":1,"gen_end":10680,"gen_start":10174,"node":58,"role":"declaration","source":0,"src_end":7424,"src_start":7110},{"artifact":1,"gen_end":11192,"gen_start":10680,"node":59,"role":"declaration","source":0,"src_end":7746,"src_start":7426},{"artifact":1,"gen_end":11704,"gen_start":11192,"node":60,"role":"declaration","source":0,"src_end":8068,"src_start":7748},{"artifact":1,"gen_end":12216,"gen_start":11704,"node":61,"role":"declaration","source":0,"src_end":8390,"src_start":8070},{"artifact":1,"gen_end":33789,"gen_start":12216,"node":62,"role":"declaration","source":0,"src_end":39304,"src_start":8392},{"artifact":1,"gen_end":35022,"gen_start":33789,"node":63,"role":"declaration","source":0,"src_end":40479,"src_start":39306},{"artifact":1,"gen_end":36807,"gen_start":35022,"node":64,"role":"declaration","source":0,"src_end":41949,"src_start":40481},{"artifact":1,"gen_end":37299,"gen_start":36807,"node":65,"role":"declaration","source":0,"src_end":42245,"src_start":41951},{"artifact":1,"gen_end":37859,"gen_start":37299,"node":66,"role":"declaration","source":0,"src_end":42696,"src_start":42247},{"artifact":1,"gen_end":62160,"gen_start":37859,"node":67,"role":"declaration","source":0,"src_end":80179,"src_start":42698},{"artifact":1,"gen_end":68896,"gen_start":62160,"node":68,"role":"declaration","source":0,"src_end":87652,"src_start":80181},{"artifact":1,"gen_end":69357,"gen_start":68896,"node":69,"role":"declaration","source":0,"src_end":87954,"src_start":87654},{"artifact":1,"gen_end":71199,"gen_start":69357,"node":70,"role":"declaration","source":0,"src_end":90259,"src_start":87956},{"artifact":1,"gen_end":337147,"gen_start":71199,"node":71,"role":"declaration","source":0,"src_end":408473,"src_start":90261},{"artifact":1,"gen_end":350721,"gen_start":337147,"node":72,"role":"declaration","source":0,"src_end":423624,"src_start":408475},{"artifact":1,"gen_end":352052,"gen_start":350721,"node":73,"role":"declaration","source":0,"src_end":424840,"src_start":423626},{"artifact":1,"gen_end":353188,"gen_start":352052,"node":74,"role":"declaration","source":0,"src_end":425975,"src_start":424842},{"artifact":1,"gen_end":353983,"gen_start":353188,"node":75,"role":"declaration","source":0,"src_end":426603,"src_start":425977},{"artifact":1,"gen_end":353998,"gen_start":353983,"node":38,"role":"declaration","source":0,"src_end":426639,"src_start":0}],"module":"TargetSemantics","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-latex-module"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/TargetSemantics.lex.tex","sha256":"92551ec717ba14a68c53203b5ea1f68359902201116de69c2816668038eb4a60"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/expected/build/maps/LexLeanTarget/TargetSyntax.map.json b/compiler/expected/build/maps/LexLeanTarget/TargetSyntax.map.json index b466637a7..7409f92f7 100644 --- a/compiler/expected/build/maps/LexLeanTarget/TargetSyntax.map.json +++ b/compiler/expected/build/maps/LexLeanTarget/TargetSyntax.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetSyntax.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetSyntax.tex"}],"mappings":[{"artifact":0,"gen_end":209,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":0,"gen_end":303,"gen_start":209,"node":1,"role":"declaration","source":0,"src_end":442,"src_start":121},{"artifact":0,"gen_end":360,"gen_start":303,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":444},{"artifact":0,"gen_end":623,"gen_start":360,"node":3,"role":"declaration","source":0,"src_end":1161,"src_start":609},{"artifact":0,"gen_end":1163,"gen_start":623,"node":4,"role":"declaration","source":0,"src_end":2079,"src_start":1163},{"artifact":0,"gen_end":1339,"gen_start":1163,"node":5,"role":"declaration","source":0,"src_end":2649,"src_start":2081},{"artifact":0,"gen_end":1909,"gen_start":1339,"node":6,"role":"declaration","source":0,"src_end":4148,"src_start":2651},{"artifact":0,"gen_end":2417,"gen_start":1909,"node":7,"role":"declaration","source":0,"src_end":4825,"src_start":4150},{"artifact":0,"gen_end":2497,"gen_start":2417,"node":8,"role":"declaration","source":0,"src_end":4974,"src_start":4827},{"artifact":0,"gen_end":2559,"gen_start":2497,"node":9,"role":"declaration","source":0,"src_end":5099,"src_start":4976},{"artifact":0,"gen_end":2666,"gen_start":2559,"node":10,"role":"declaration","source":0,"src_end":5325,"src_start":5101},{"artifact":0,"gen_end":2748,"gen_start":2666,"node":11,"role":"declaration","source":0,"src_end":5482,"src_start":5327},{"artifact":0,"gen_end":2780,"gen_start":2748,"node":0,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":12,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":1,"gen_end":627,"gen_start":134,"node":13,"role":"declaration","source":0,"src_end":442,"src_start":121},{"artifact":1,"gen_end":858,"gen_start":627,"node":14,"role":"declaration","source":0,"src_end":607,"src_start":444},{"artifact":1,"gen_end":1726,"gen_start":858,"node":15,"role":"declaration","source":0,"src_end":1161,"src_start":609},{"artifact":1,"gen_end":3178,"gen_start":1726,"node":16,"role":"declaration","source":0,"src_end":2079,"src_start":1163},{"artifact":1,"gen_end":4106,"gen_start":3178,"node":17,"role":"declaration","source":0,"src_end":2649,"src_start":2081},{"artifact":1,"gen_end":6591,"gen_start":4106,"node":18,"role":"declaration","source":0,"src_end":4148,"src_start":2651},{"artifact":1,"gen_end":7585,"gen_start":6591,"node":19,"role":"declaration","source":0,"src_end":4825,"src_start":4150},{"artifact":1,"gen_end":7771,"gen_start":7585,"node":20,"role":"declaration","source":0,"src_end":4974,"src_start":4827},{"artifact":1,"gen_end":7908,"gen_start":7771,"node":21,"role":"declaration","source":0,"src_end":5099,"src_start":4976},{"artifact":1,"gen_end":8198,"gen_start":7908,"node":22,"role":"declaration","source":0,"src_end":5325,"src_start":5101},{"artifact":1,"gen_end":8391,"gen_start":8198,"node":23,"role":"declaration","source":0,"src_end":5482,"src_start":5327},{"artifact":1,"gen_end":8406,"gen_start":8391,"node":12,"role":"declaration","source":0,"src_end":5518,"src_start":0}],"module":"TargetSyntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-latex-module"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"}],"semantic_id":"c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517","source_id":"ce718723d5d252a9adafdc3cb3b76931b1d91e053dd3e7e31bcb9b9496a1941c","sources":[{"id":0,"kind":"file","path":"src/TargetSyntax.lex.tex","sha256":"943d39daf9ece2d492cf8b15ba2df218f84031dbf0757b8ee765d240df55276e"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanTarget/TargetSyntax.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanTarget/TargetSyntax.tex"}],"mappings":[{"artifact":0,"gen_end":209,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":0,"gen_end":303,"gen_start":209,"node":1,"role":"declaration","source":0,"src_end":442,"src_start":121},{"artifact":0,"gen_end":360,"gen_start":303,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":444},{"artifact":0,"gen_end":623,"gen_start":360,"node":3,"role":"declaration","source":0,"src_end":1161,"src_start":609},{"artifact":0,"gen_end":1163,"gen_start":623,"node":4,"role":"declaration","source":0,"src_end":2079,"src_start":1163},{"artifact":0,"gen_end":1339,"gen_start":1163,"node":5,"role":"declaration","source":0,"src_end":2649,"src_start":2081},{"artifact":0,"gen_end":1909,"gen_start":1339,"node":6,"role":"declaration","source":0,"src_end":4148,"src_start":2651},{"artifact":0,"gen_end":2417,"gen_start":1909,"node":7,"role":"declaration","source":0,"src_end":4825,"src_start":4150},{"artifact":0,"gen_end":2497,"gen_start":2417,"node":8,"role":"declaration","source":0,"src_end":4974,"src_start":4827},{"artifact":0,"gen_end":2559,"gen_start":2497,"node":9,"role":"declaration","source":0,"src_end":5099,"src_start":4976},{"artifact":0,"gen_end":2666,"gen_start":2559,"node":10,"role":"declaration","source":0,"src_end":5325,"src_start":5101},{"artifact":0,"gen_end":2748,"gen_start":2666,"node":11,"role":"declaration","source":0,"src_end":5482,"src_start":5327},{"artifact":0,"gen_end":2780,"gen_start":2748,"node":0,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":12,"role":"declaration","source":0,"src_end":5518,"src_start":0},{"artifact":1,"gen_end":627,"gen_start":134,"node":13,"role":"declaration","source":0,"src_end":442,"src_start":121},{"artifact":1,"gen_end":858,"gen_start":627,"node":14,"role":"declaration","source":0,"src_end":607,"src_start":444},{"artifact":1,"gen_end":1726,"gen_start":858,"node":15,"role":"declaration","source":0,"src_end":1161,"src_start":609},{"artifact":1,"gen_end":3178,"gen_start":1726,"node":16,"role":"declaration","source":0,"src_end":2079,"src_start":1163},{"artifact":1,"gen_end":4106,"gen_start":3178,"node":17,"role":"declaration","source":0,"src_end":2649,"src_start":2081},{"artifact":1,"gen_end":6591,"gen_start":4106,"node":18,"role":"declaration","source":0,"src_end":4148,"src_start":2651},{"artifact":1,"gen_end":7585,"gen_start":6591,"node":19,"role":"declaration","source":0,"src_end":4825,"src_start":4150},{"artifact":1,"gen_end":7771,"gen_start":7585,"node":20,"role":"declaration","source":0,"src_end":4974,"src_start":4827},{"artifact":1,"gen_end":7908,"gen_start":7771,"node":21,"role":"declaration","source":0,"src_end":5099,"src_start":4976},{"artifact":1,"gen_end":8198,"gen_start":7908,"node":22,"role":"declaration","source":0,"src_end":5325,"src_start":5101},{"artifact":1,"gen_end":8391,"gen_start":8198,"node":23,"role":"declaration","source":0,"src_end":5482,"src_start":5327},{"artifact":1,"gen_end":8406,"gen_start":8391,"node":12,"role":"declaration","source":0,"src_end":5518,"src_start":0}],"module":"TargetSyntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-latex-module"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"}],"semantic_id":"e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb","source_id":"965efd311d3549a7c17dd823b4418cfee906beecd273f4bfcafb371c36d9ce99","sources":[{"id":0,"kind":"file","path":"src/TargetSyntax.lex.tex","sha256":"943d39daf9ece2d492cf8b15ba2df218f84031dbf0757b8ee765d240df55276e"}],"spec":"lexlean/source-map/1"} diff --git a/compiler/lexlean.lock b/compiler/lexlean.lock index 2bb01f7e4..b2991ab01 100644 --- a/compiler/lexlean.lock +++ b/compiler/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "ef58478b65de0ad784269ab3513059f5afbb7f461bda9476efce78344301755e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/compiler/rust/negative/arithmetic-invented-overflow.json b/compiler/rust/negative/arithmetic-invented-overflow.json index 64e80dd04..351a06b45 100644 --- a/compiler/rust/negative/arithmetic-invented-overflow.json +++ b/compiler/rust/negative/arithmetic-invented-overflow.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"booleans_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"booleans_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/arithmetic-undeclared-overflow.json b/compiler/rust/negative/arithmetic-undeclared-overflow.json index b0f92a8d2..9f53c0edf 100644 --- a/compiler/rust/negative/arithmetic-undeclared-overflow.json +++ b/compiler/rust/negative/arithmetic-undeclared-overflow.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/export-arity.json b/compiler/rust/negative/export-arity.json index 834eb9c7b..6ea4f4b42 100644 --- a/compiler/rust/negative/export-arity.json +++ b/compiler/rust/negative/export-arity.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/hidden-allocation-list.json b/compiler/rust/negative/hidden-allocation-list.json index 7c54d2e38..2806a610a 100644 --- a/compiler/rust/negative/hidden-allocation-list.json +++ b/compiler/rust/negative/hidden-allocation-list.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"lists_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"lists_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/hidden-allocation-recursive-type.json b/compiler/rust/negative/hidden-allocation-recursive-type.json index eab5a6ba0..5e74168a5 100644 --- a/compiler/rust/negative/hidden-allocation-recursive-type.json +++ b/compiler/rust/negative/hidden-allocation-recursive-type.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":[]}],"name":"adt_evaluation_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":0,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":4}},{"index":1,"kind":"field","value":{"kind":"var","name":4}}],"operation":{"kind":"nat_add"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"function":0,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":[]}],"name":"adt_evaluation_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":0,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":4}},{"index":1,"kind":"field","value":{"kind":"var","name":4}}],"operation":{"kind":"nat_add"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"function":0,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-exported-twice.json b/compiler/rust/negative/identifier-exported-twice.json index 23676e3e1..a2f6ee405 100644 --- a/compiler/rust/negative/identifier-exported-twice.json +++ b/compiler/rust/negative/identifier-exported-twice.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]},{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]},{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-generated.json b/compiler/rust/negative/identifier-generated.json index b64655b4e..3a181083e 100644 --- a/compiler/rust/negative/identifier-generated.json +++ b/compiler/rust/negative/identifier-generated.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"v3","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"v3","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-keyword.json b/compiler/rust/negative/identifier-keyword.json index 0ee6b49bd..365e6772c 100644 --- a/compiler/rust/negative/identifier-keyword.json +++ b/compiler/rust/negative/identifier-keyword.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"match","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"match","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-not-snake-case.json b/compiler/rust/negative/identifier-not-snake-case.json index 113245ee6..a8c50e5de 100644 --- a/compiler/rust/negative/identifier-not-snake-case.json +++ b/compiler/rust/negative/identifier-not-snake-case.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"Run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"Run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-reserved-crate.json b/compiler/rust/negative/identifier-reserved-crate.json index d51485117..92a61c527 100644 --- a/compiler/rust/negative/identifier-reserved-crate.json +++ b/compiler/rust/negative/identifier-reserved-crate.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"core","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"core","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-runtime-function.json b/compiler/rust/negative/identifier-runtime-function.json index 43c4909af..5289e433f 100644 --- a/compiler/rust/negative/identifier-runtime-function.json +++ b/compiler/rust/negative/identifier-runtime-function.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"nat_add","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"nat_add","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/identifier-runtime-item.json b/compiler/rust/negative/identifier-runtime-item.json index d05700104..5876158c3 100644 --- a/compiler/rust/negative/identifier-runtime-item.json +++ b/compiler/rust/negative/identifier-runtime-item.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"tick","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"tick","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/malformed-unknown-member.json b/compiler/rust/negative/malformed-unknown-member.json index 80cb4694f..e01bc297e 100644 --- a/compiler/rust/negative/malformed-unknown-member.json +++ b/compiler/rust/negative/malformed-unknown-member.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","unchecked":true,"version":"1.0.0"} \ No newline at end of file +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","unchecked":true,"version":"1.0.0"} \ No newline at end of file diff --git a/compiler/rust/negative/ownership-copy-list.json b/compiler/rust/negative/ownership-copy-list.json index 25b156d44..1c3e3d443 100644 --- a/compiler/rust/negative/ownership-copy-list.json +++ b/compiler/rust/negative/ownership-copy-list.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy"]}],"name":"lists_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy"]}],"name":"lists_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/unsupported-function-boundary.json b/compiler/rust/negative/unsupported-function-boundary.json index b03279039..1e88f9f3b 100644 --- a/compiler/rust/negative/unsupported-function-boundary.json +++ b/compiler/rust/negative/unsupported-function-boundary.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":["own","own"]}],"name":"closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":["own","own"]}],"name":"closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/unsupported-function-in-record.json b/compiler/rust/negative/unsupported-function-in-record.json index 49cffe4b3..96e8d52be 100644 --- a/compiler/rust/negative/unsupported-function-in-record.json +++ b/compiler/rust/negative/unsupported-function-in-record.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}]]}],"functions":[{"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}]]}],"functions":[{"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/unsupported-uninhabited-value.json b/compiler/rust/negative/unsupported-uninhabited-value.json index 16136db10..c2b59cf7a 100644 --- a/compiler/rust/negative/unsupported-uninhabited-value.json +++ b/compiler/rust/negative/unsupported-uninhabited-value.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"target":{"function":1,"kind":"call","operands":[]}},"parameters":[],"result":{"kind":"nat"},"types":[]},{"body":{"function":1,"kind":"call","operands":[]},"parameters":[],"result":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"target":{"function":1,"kind":"call","operands":[]}},"parameters":[],"result":{"kind":"nat"},"types":[]},{"body":{"function":1,"kind":"call","operands":[]},"parameters":[],"result":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/negative/version-noncanonical.json b/compiler/rust/negative/version-noncanonical.json index 78c9cfb89..d8a6e3457 100644 --- a/compiler/rust/negative/version-noncanonical.json +++ b/compiler/rust/negative/version-noncanonical.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.01.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.01.0"} diff --git a/compiler/rust/negative/version-overflow.json b/compiler/rust/negative/version-overflow.json index 73f65fcaa..047ed8274 100644 --- a/compiler/rust/negative/version-overflow.json +++ b/compiler/rust/negative/version-overflow.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"99999999999999999999.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"99999999999999999999.0.0"} diff --git a/compiler/rust/rust-core/boolean-shapes/package.json b/compiler/rust/rust-core/boolean-shapes/package.json index 7e80893bb..1003ab1b7 100644 --- a/compiler/rust/rust-core/boolean-shapes/package.json +++ b/compiler/rust/rust-core/boolean-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"boolean_shapes_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"condition":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"zero"}},{"binders":[5],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}},"types":[{"kind":"bool"},{"kind":"bool"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"boolean_shapes_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"condition":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"zero"}},{"binders":[5],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}},"types":[{"kind":"bool"},{"kind":"bool"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/boolean-shapes/provenance.json b/compiler/rust/rust-core/boolean-shapes/provenance.json index b6d3ba1fd..d8d128a8d 100644 --- a/compiler/rust/rust-core/boolean-shapes/provenance.json +++ b/compiler/rust/rust-core/boolean-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"270742331c4b51375f678f97518fef1740d1842a36da8c59f5d3fea16ed91ff2","src/lib.rs":"65e63587931891835448f453c9452a33b30003641aa1f8fc341fdb2102aba0a1"},"name":"boolean_shapes_core","profile":"rust-core","program":"08c54665d09d55ac525712aaf1c9be1ab4a4335c07dcc89b2bc107f4e151e2c9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"270742331c4b51375f678f97518fef1740d1842a36da8c59f5d3fea16ed91ff2","src/lib.rs":"65e63587931891835448f453c9452a33b30003641aa1f8fc341fdb2102aba0a1"},"name":"boolean_shapes_core","profile":"rust-core","program":"08c54665d09d55ac525712aaf1c9be1ab4a4335c07dcc89b2bc107f4e151e2c9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-captures/package.json b/compiler/rust/rust-core/closure-captures/package.json index 777c3b8df..450f54a7f 100644 --- a/compiler/rust/rust-core/closure-captures/package.json +++ b/compiler/rust/rust-core/closure-captures/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"closure_captures_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"closure_captures_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-captures/provenance.json b/compiler/rust/rust-core/closure-captures/provenance.json index c312e85e8..887aa7c89 100644 --- a/compiler/rust/rust-core/closure-captures/provenance.json +++ b/compiler/rust/rust-core/closure-captures/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"513f6df0a5c7e40a18b97e58427e056e0ceece99bbb616056ee599ebc220a9bf","src/lib.rs":"18cfe1a5740827e7c2ddd1af708b09451d92a158072840a063fe08a4f26ee32f"},"name":"closure_captures_core","profile":"rust-core","program":"e2d52d5414c5f9639f8e127b054cd3820f186da100f2dd2c1b707805abba379f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"513f6df0a5c7e40a18b97e58427e056e0ceece99bbb616056ee599ebc220a9bf","src/lib.rs":"18cfe1a5740827e7c2ddd1af708b09451d92a158072840a063fe08a4f26ee32f"},"name":"closure_captures_core","profile":"rust-core","program":"e2d52d5414c5f9639f8e127b054cd3820f186da100f2dd2c1b707805abba379f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-inline/package.json b/compiler/rust/rust-core/closure-inline/package.json index de32c6f5e..8d77c1ad8 100644 --- a/compiler/rust/rust-core/closure-inline/package.json +++ b/compiler/rust/rust-core/closure-inline/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_inline_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}],"target":{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_inline_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}],"target":{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-inline/provenance.json b/compiler/rust/rust-core/closure-inline/provenance.json index be90a19ca..c6879afd3 100644 --- a/compiler/rust/rust-core/closure-inline/provenance.json +++ b/compiler/rust/rust-core/closure-inline/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"335aa4c0de5f90930e2c19c8a9fea191702847d951ad7e2ee90795a416482576","src/lib.rs":"42788e5240eb4ac7026621a0ef10a381221e18e2a25e449814e4532ba2b0e4bd"},"name":"closure_inline_core","profile":"rust-core","program":"cce3e8632d8c7b42f7961f9a6c0f734f50ea0eab68ab6e496f16558de67003ce","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"335aa4c0de5f90930e2c19c8a9fea191702847d951ad7e2ee90795a416482576","src/lib.rs":"42788e5240eb4ac7026621a0ef10a381221e18e2a25e449814e4532ba2b0e4bd"},"name":"closure_inline_core","profile":"rust-core","program":"cce3e8632d8c7b42f7961f9a6c0f734f50ea0eab68ab6e496f16558de67003ce","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-uninhabited/package.json b/compiler/rust/rust-core/closure-uninhabited/package.json index 768852566..b769817f5 100644 --- a/compiler/rust/rust-core/closure-uninhabited/package.json +++ b/compiler/rust/rust-core/closure-uninhabited/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"closure_uninhabited_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":2}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"closure_uninhabited_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":2}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/closure-uninhabited/provenance.json b/compiler/rust/rust-core/closure-uninhabited/provenance.json index d10c9f47a..338e2fdd3 100644 --- a/compiler/rust/rust-core/closure-uninhabited/provenance.json +++ b/compiler/rust/rust-core/closure-uninhabited/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"028327704b4d2dc090da323b38046c4165b5f1a96c1fd53f9be114292c6c29a5","src/lib.rs":"cc89f8dec9d4c8de63b66e7895279423fe44c964a56d26681813898faec4a14b"},"name":"closure_uninhabited_core","profile":"rust-core","program":"057be489c5323c3dc11411532fd63e39ec3436d200fc45dfd8e385bec6106b04","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"028327704b4d2dc090da323b38046c4165b5f1a96c1fd53f9be114292c6c29a5","src/lib.rs":"cc89f8dec9d4c8de63b66e7895279423fe44c964a56d26681813898faec4a14b"},"name":"closure_uninhabited_core","profile":"rust-core","program":"057be489c5323c3dc11411532fd63e39ec3436d200fc45dfd8e385bec6106b04","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/convert/package.json b/compiler/rust/rust-core/convert/package.json index d81e6c951..4b5d79ca9 100644 --- a/compiler/rust/rust-core/convert/package.json +++ b/compiler/rust/rust-core/convert/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"convert_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"fixed","width":"u8"}},{"kind":"option","value":{"kind":"fixed","width":"u16"}},{"kind":"option","value":{"kind":"fixed","width":"u32"}},{"kind":"option","value":{"kind":"fixed","width":"u64"}},{"kind":"option","value":{"kind":"fixed","width":"i8"}},{"kind":"option","value":{"kind":"fixed","width":"i16"}},{"kind":"option","value":{"kind":"fixed","width":"i32"}},{"kind":"option","value":{"kind":"fixed","width":"i64"}}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"65535"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-32768"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"convert_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"fixed","width":"u8"}},{"kind":"option","value":{"kind":"fixed","width":"u16"}},{"kind":"option","value":{"kind":"fixed","width":"u32"}},{"kind":"option","value":{"kind":"fixed","width":"u64"}},{"kind":"option","value":{"kind":"fixed","width":"i8"}},{"kind":"option","value":{"kind":"fixed","width":"i16"}},{"kind":"option","value":{"kind":"fixed","width":"i32"}},{"kind":"option","value":{"kind":"fixed","width":"i64"}}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"65535"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-32768"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/convert/provenance.json b/compiler/rust/rust-core/convert/provenance.json index bf2aa3bb1..fdd52b0c8 100644 --- a/compiler/rust/rust-core/convert/provenance.json +++ b/compiler/rust/rust-core/convert/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eb5b8719a62544af24875ac26fc79a3ecac479e6ae96bba411b93c91d8be2115","src/lib.rs":"467414792ece513732505a93277d6770bcd85be30d5457ffdc72d3bfde288c5a"},"name":"convert_core","profile":"rust-core","program":"53f534696ea7212909ffcf637122ef370f71853fc0ce58655b91be97455279f5","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eb5b8719a62544af24875ac26fc79a3ecac479e6ae96bba411b93c91d8be2115","src/lib.rs":"467414792ece513732505a93277d6770bcd85be30d5457ffdc72d3bfde288c5a"},"name":"convert_core","profile":"rust-core","program":"53f534696ea7212909ffcf637122ef370f71853fc0ce58655b91be97455279f5","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fallible-condition-value/package.json b/compiler/rust/rust-core/fallible-condition-value/package.json index 3fbecff78..d40fc7978 100644 --- a/compiler/rust/rust-core/fallible-condition-value/package.json +++ b/compiler/rust/rust-core/fallible-condition-value/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"fallible_condition_value_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"fallible_condition_value_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fallible-condition-value/provenance.json b/compiler/rust/rust-core/fallible-condition-value/provenance.json index 6217636dc..b5710243f 100644 --- a/compiler/rust/rust-core/fallible-condition-value/provenance.json +++ b/compiler/rust/rust-core/fallible-condition-value/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1c786dda2900c26d0db6af21a1218b68ab82fcc35902da344bb9903a8b971c96","src/lib.rs":"bddb19e6192a93407de2d177726dd4012b6f70e6e92f42f1396c5d985f0092bb"},"name":"fallible_condition_value_core","profile":"rust-core","program":"1e4bbfc9aa1667d930aa5d3c7df5105e11161bde3842639d8fd684b9e7c9ab80","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1c786dda2900c26d0db6af21a1218b68ab82fcc35902da344bb9903a8b971c96","src/lib.rs":"bddb19e6192a93407de2d177726dd4012b6f70e6e92f42f1396c5d985f0092bb"},"name":"fallible_condition_value_core","profile":"rust-core","program":"1e4bbfc9aa1667d930aa5d3c7df5105e11161bde3842639d8fd684b9e7c9ab80","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i16/package.json b/compiler/rust/rust-core/fixed-width-i16/package.json index 78e7dfdb2..aed4c5a70 100644 --- a/compiler/rust/rust-core/fixed-width-i16/package.json +++ b/compiler/rust/rust-core/fixed-width-i16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i16_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i16_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i16/provenance.json b/compiler/rust/rust-core/fixed-width-i16/provenance.json index 19ba3c3a1..6e159f289 100644 --- a/compiler/rust/rust-core/fixed-width-i16/provenance.json +++ b/compiler/rust/rust-core/fixed-width-i16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"853341a44b5be6732073d7787b210c4d0eea984965d76d8f9f75225017444c06","src/lib.rs":"7c2699d6b1bbced03ccb18536fa78c7ee2f01344c07d13742eaa100c48acfa14"},"name":"fixed_width_i16_core","profile":"rust-core","program":"23f1a6e3b665ccabf568dce2bcfd6ca2247170568ae24f097dc9f260f0d2369e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"853341a44b5be6732073d7787b210c4d0eea984965d76d8f9f75225017444c06","src/lib.rs":"7c2699d6b1bbced03ccb18536fa78c7ee2f01344c07d13742eaa100c48acfa14"},"name":"fixed_width_i16_core","profile":"rust-core","program":"23f1a6e3b665ccabf568dce2bcfd6ca2247170568ae24f097dc9f260f0d2369e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i32/package.json b/compiler/rust/rust-core/fixed-width-i32/package.json index e360c30d0..0be74df1a 100644 --- a/compiler/rust/rust-core/fixed-width-i32/package.json +++ b/compiler/rust/rust-core/fixed-width-i32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i32_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i32_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i32/provenance.json b/compiler/rust/rust-core/fixed-width-i32/provenance.json index 74da52433..11efec56b 100644 --- a/compiler/rust/rust-core/fixed-width-i32/provenance.json +++ b/compiler/rust/rust-core/fixed-width-i32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d8447a870cb64afbda2e9b3a3da2c9ca3ed1e8795f70e7d67c0c9e74148f8df0","src/lib.rs":"49031024a1bb8be1243847a84d67804aa79ceecdf659cc6a8d9bdbe771be2468"},"name":"fixed_width_i32_core","profile":"rust-core","program":"a55c0f3839fd471d83e04fe51ad076da864407a9027bc8225331cb1e562880ee","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d8447a870cb64afbda2e9b3a3da2c9ca3ed1e8795f70e7d67c0c9e74148f8df0","src/lib.rs":"49031024a1bb8be1243847a84d67804aa79ceecdf659cc6a8d9bdbe771be2468"},"name":"fixed_width_i32_core","profile":"rust-core","program":"a55c0f3839fd471d83e04fe51ad076da864407a9027bc8225331cb1e562880ee","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i64/package.json b/compiler/rust/rust-core/fixed-width-i64/package.json index 08f1ea3c7..773de814c 100644 --- a/compiler/rust/rust-core/fixed-width-i64/package.json +++ b/compiler/rust/rust-core/fixed-width-i64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i64_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i64_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i64/provenance.json b/compiler/rust/rust-core/fixed-width-i64/provenance.json index 58d7641fe..0afe8bc15 100644 --- a/compiler/rust/rust-core/fixed-width-i64/provenance.json +++ b/compiler/rust/rust-core/fixed-width-i64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b5daf860b0116ece635b5ee6bec0ad90e970e77b3bb3f4cbe5a311fb1bacad1b","src/lib.rs":"f4f0aded7852cfc7562eb3935c39c1c9aa026e0432d874094bfda8276b76a4ae"},"name":"fixed_width_i64_core","profile":"rust-core","program":"bf6c9acc0c25eb22d8c1deb59574ad70d65f06123c556ed17e1b7c5bbc5aa902","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b5daf860b0116ece635b5ee6bec0ad90e970e77b3bb3f4cbe5a311fb1bacad1b","src/lib.rs":"f4f0aded7852cfc7562eb3935c39c1c9aa026e0432d874094bfda8276b76a4ae"},"name":"fixed_width_i64_core","profile":"rust-core","program":"bf6c9acc0c25eb22d8c1deb59574ad70d65f06123c556ed17e1b7c5bbc5aa902","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i8/package.json b/compiler/rust/rust-core/fixed-width-i8/package.json index 35200cd07..0e6b26165 100644 --- a/compiler/rust/rust-core/fixed-width-i8/package.json +++ b/compiler/rust/rust-core/fixed-width-i8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i8_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i8_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-i8/provenance.json b/compiler/rust/rust-core/fixed-width-i8/provenance.json index 7b2c47f41..de002a5fa 100644 --- a/compiler/rust/rust-core/fixed-width-i8/provenance.json +++ b/compiler/rust/rust-core/fixed-width-i8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e3c91103a71f1b25c70eb55ae56707e4ba1d1d599e5646271c92ff84e40a4215","src/lib.rs":"ecf7bc047379c906cdf15240bdaf8989a82293c10e1bc119b64808179f2ca777"},"name":"fixed_width_i8_core","profile":"rust-core","program":"d57d16e24c0ae93fc46223897266514db7bf77781397039e12b9f8781e3b6631","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e3c91103a71f1b25c70eb55ae56707e4ba1d1d599e5646271c92ff84e40a4215","src/lib.rs":"ecf7bc047379c906cdf15240bdaf8989a82293c10e1bc119b64808179f2ca777"},"name":"fixed_width_i8_core","profile":"rust-core","program":"d57d16e24c0ae93fc46223897266514db7bf77781397039e12b9f8781e3b6631","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u16/package.json b/compiler/rust/rust-core/fixed-width-u16/package.json index a3e117523..3bb4c2a09 100644 --- a/compiler/rust/rust-core/fixed-width-u16/package.json +++ b/compiler/rust/rust-core/fixed-width-u16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u16_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u16_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u16/provenance.json b/compiler/rust/rust-core/fixed-width-u16/provenance.json index 433b68e2b..49a3517f2 100644 --- a/compiler/rust/rust-core/fixed-width-u16/provenance.json +++ b/compiler/rust/rust-core/fixed-width-u16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eb503bab98acf82cf1b106647d9825b61c675c364249f4b69bf9fbed22e53883","src/lib.rs":"83a09ad442b65134d7eff880560c2c445ee528c9c8a416494a9116934e4eebe8"},"name":"fixed_width_u16_core","profile":"rust-core","program":"9b805d1f67c7b7fa48388bf6b3921d64f311b660e5894d4c4ad299390f0ef380","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eb503bab98acf82cf1b106647d9825b61c675c364249f4b69bf9fbed22e53883","src/lib.rs":"83a09ad442b65134d7eff880560c2c445ee528c9c8a416494a9116934e4eebe8"},"name":"fixed_width_u16_core","profile":"rust-core","program":"9b805d1f67c7b7fa48388bf6b3921d64f311b660e5894d4c4ad299390f0ef380","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u32/package.json b/compiler/rust/rust-core/fixed-width-u32/package.json index 39c7b6b25..fd66f5f53 100644 --- a/compiler/rust/rust-core/fixed-width-u32/package.json +++ b/compiler/rust/rust-core/fixed-width-u32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u32_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u32_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u32/provenance.json b/compiler/rust/rust-core/fixed-width-u32/provenance.json index 4ac3c0df8..393041a7f 100644 --- a/compiler/rust/rust-core/fixed-width-u32/provenance.json +++ b/compiler/rust/rust-core/fixed-width-u32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3c62f6890f19778d954fad4331fb626c474b3d18b9fcd5ad76a5ff5789bce13b","src/lib.rs":"1a4b701574c9b97cdb95175a94c658da613a639e1732c6083f0fdf43c42d7035"},"name":"fixed_width_u32_core","profile":"rust-core","program":"b0d32e1ba47aad96742baed7ac5cc12f337d84e7d478c3d00ed0992be2861fe1","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3c62f6890f19778d954fad4331fb626c474b3d18b9fcd5ad76a5ff5789bce13b","src/lib.rs":"1a4b701574c9b97cdb95175a94c658da613a639e1732c6083f0fdf43c42d7035"},"name":"fixed_width_u32_core","profile":"rust-core","program":"b0d32e1ba47aad96742baed7ac5cc12f337d84e7d478c3d00ed0992be2861fe1","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u64/package.json b/compiler/rust/rust-core/fixed-width-u64/package.json index 75edf051c..df39c2db7 100644 --- a/compiler/rust/rust-core/fixed-width-u64/package.json +++ b/compiler/rust/rust-core/fixed-width-u64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u64_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u64_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u64/provenance.json b/compiler/rust/rust-core/fixed-width-u64/provenance.json index 4f7a4ffe8..d8f7854f9 100644 --- a/compiler/rust/rust-core/fixed-width-u64/provenance.json +++ b/compiler/rust/rust-core/fixed-width-u64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e409382597a6c5de3bfcab4092daee6af3ddb29c71f0cc12637e686505807e41","src/lib.rs":"2f3d0a88af320a1f613631fbf174d6c248b30e69840aa7c35094b7541e7c1251"},"name":"fixed_width_u64_core","profile":"rust-core","program":"d173c6c0813a7ca7f471cf3a55f2a25c4771bbeea58ca9cd42e5ee35e352fc43","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e409382597a6c5de3bfcab4092daee6af3ddb29c71f0cc12637e686505807e41","src/lib.rs":"2f3d0a88af320a1f613631fbf174d6c248b30e69840aa7c35094b7541e7c1251"},"name":"fixed_width_u64_core","profile":"rust-core","program":"d173c6c0813a7ca7f471cf3a55f2a25c4771bbeea58ca9cd42e5ee35e352fc43","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u8-passing/package.json b/compiler/rust/rust-core/fixed-width-u8-passing/package.json index 53688d8d6..f359830a3 100644 --- a/compiler/rust/rust-core/fixed-width-u8-passing/package.json +++ b/compiler/rust/rust-core/fixed-width-u8-passing/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy","borrow","own"]}],"name":"fixed_width_u8_passing_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy","borrow","own"]}],"name":"fixed_width_u8_passing_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u8-passing/provenance.json b/compiler/rust/rust-core/fixed-width-u8-passing/provenance.json index 12055f6a0..575a3a8ef 100644 --- a/compiler/rust/rust-core/fixed-width-u8-passing/provenance.json +++ b/compiler/rust/rust-core/fixed-width-u8-passing/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"13014f6dfaeb8d3a6c42e7459d1355afbcd6654dadfbda1c9bd24b13598d1076","src/lib.rs":"415e38c5ed71b8443393ae8f6e32f1b7d9d1ec7b16465c9aa07b204493845847"},"name":"fixed_width_u8_passing_core","profile":"rust-core","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"13014f6dfaeb8d3a6c42e7459d1355afbcd6654dadfbda1c9bd24b13598d1076","src/lib.rs":"415e38c5ed71b8443393ae8f6e32f1b7d9d1ec7b16465c9aa07b204493845847"},"name":"fixed_width_u8_passing_core","profile":"rust-core","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u8/package.json b/compiler/rust/rust-core/fixed-width-u8/package.json index 4d3cf4797..14e4ad57d 100644 --- a/compiler/rust/rust-core/fixed-width-u8/package.json +++ b/compiler/rust/rust-core/fixed-width-u8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u8_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u8_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/fixed-width-u8/provenance.json b/compiler/rust/rust-core/fixed-width-u8/provenance.json index fcc473bbc..1e0b53b03 100644 --- a/compiler/rust/rust-core/fixed-width-u8/provenance.json +++ b/compiler/rust/rust-core/fixed-width-u8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f6bd44702dee9317d3ccfb7cf717124b71b06ad65fbbd675d1efa63547106ec4","src/lib.rs":"b51f3227ad244f0c2abc01f6ed2613919f81b4488f247e489119151d7ae123ac"},"name":"fixed_width_u8_core","profile":"rust-core","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f6bd44702dee9317d3ccfb7cf717124b71b06ad65fbbd675d1efa63547106ec4","src/lib.rs":"b51f3227ad244f0c2abc01f6ed2613919f81b4488f247e489119151d7ae123ac"},"name":"fixed_width_u8_core","profile":"rust-core","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/function-shapes/package.json b/compiler/rust/rust-core/function-shapes/package.json index a1977aa2f..2cc0849a6 100644 --- a/compiler/rust/rust-core/function-shapes/package.json +++ b/compiler/rust/rust-core/function-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"function_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"3"}}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"4"}}}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"value","type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"5"}}}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}}]},{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"6"}}}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":false}}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"value","type":{"index":0,"kind":"adt"},"value":{"constructor":0,"fields":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"adt"}}]},{"function":9,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"1"}}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"types":[]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bool"}]},{"body":{"index":0,"kind":"field","value":{"arms":[{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"function_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"3"}}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"4"}}}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"value","type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"5"}}}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}}]},{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"6"}}}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":false}}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"value","type":{"index":0,"kind":"adt"},"value":{"constructor":0,"fields":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"adt"}}]},{"function":9,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"1"}}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"types":[]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bool"}]},{"body":{"index":0,"kind":"field","value":{"arms":[{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/function-shapes/provenance.json b/compiler/rust/rust-core/function-shapes/provenance.json index 382bd536b..45f000afe 100644 --- a/compiler/rust/rust-core/function-shapes/provenance.json +++ b/compiler/rust/rust-core/function-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a5df3bc62b7ea643165c769bdf602de0d1b45d0754cfeaa422f5147684987a03","src/lib.rs":"1cb7c08442da5f088b88a0935b30a29d0be5b248634b56cee80bfd7fecee7657"},"name":"function_shapes_core","profile":"rust-core","program":"5156d5b2edb83f9b58b89720da3005d24bde4f212a0a5f4d25175cc4ba0628e9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a5df3bc62b7ea643165c769bdf602de0d1b45d0754cfeaa422f5147684987a03","src/lib.rs":"1cb7c08442da5f088b88a0935b30a29d0be5b248634b56cee80bfd7fecee7657"},"name":"function_shapes_core","profile":"rust-core","program":"5156d5b2edb83f9b58b89720da3005d24bde4f212a0a5f4d25175cc4ba0628e9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-mul/package.json b/compiler/rust/rust-core/int-overflow-mul/package.json index 9e8b5c7d5..bacfb6fa7 100644 --- a/compiler/rust/rust-core/int-overflow-mul/package.json +++ b/compiler/rust/rust-core/int-overflow-mul/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_mul_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}}],"operation":{"kind":"int_mul"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_mul_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}}],"operation":{"kind":"int_mul"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-mul/provenance.json b/compiler/rust/rust-core/int-overflow-mul/provenance.json index 6b68b4e91..88b66f6e0 100644 --- a/compiler/rust/rust-core/int-overflow-mul/provenance.json +++ b/compiler/rust/rust-core/int-overflow-mul/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b186404ff099a80943ab16842d0b48cce272545c968c9d500b3b6d04d814d7f1","src/lib.rs":"6eb68f996c3bee3391f9c6853d5d9d731a8340b04bec5ed557ac5349e627d3d3"},"name":"int_overflow_mul_core","profile":"rust-core","program":"1b65e9c0d0ec40bd0d8f70b9b32771560c2418a33777717ce781aca86a2ec51c","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b186404ff099a80943ab16842d0b48cce272545c968c9d500b3b6d04d814d7f1","src/lib.rs":"6eb68f996c3bee3391f9c6853d5d9d731a8340b04bec5ed557ac5349e627d3d3"},"name":"int_overflow_mul_core","profile":"rust-core","program":"1b65e9c0d0ec40bd0d8f70b9b32771560c2418a33777717ce781aca86a2ec51c","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-neg/package.json b/compiler/rust/rust-core/int-overflow-neg/package.json index d72ff339d..e9ff7969e 100644 --- a/compiler/rust/rust-core/int-overflow-neg/package.json +++ b/compiler/rust/rust-core/int-overflow-neg/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_neg_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_neg"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_neg_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_neg"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-neg/provenance.json b/compiler/rust/rust-core/int-overflow-neg/provenance.json index 2055e8b27..ced12c58d 100644 --- a/compiler/rust/rust-core/int-overflow-neg/provenance.json +++ b/compiler/rust/rust-core/int-overflow-neg/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"06eb467e24999ffa41032bb2e1a0ec4fb5227046b7ffa2d653588f8364063e40","src/lib.rs":"6f6bd459f918babde88a365059212e78f45cabb564f1ae82ea2f08e780cda071"},"name":"int_overflow_neg_core","profile":"rust-core","program":"d9fbf0bb602a1238f9d26866ce0b3b6c6b2aaeef713f2a3912ee3377f9a21523","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"06eb467e24999ffa41032bb2e1a0ec4fb5227046b7ffa2d653588f8364063e40","src/lib.rs":"6f6bd459f918babde88a365059212e78f45cabb564f1ae82ea2f08e780cda071"},"name":"int_overflow_neg_core","profile":"rust-core","program":"d9fbf0bb602a1238f9d26866ce0b3b6c6b2aaeef713f2a3912ee3377f9a21523","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-quot/package.json b/compiler/rust/rust-core/int-overflow-quot/package.json index 3950f791d..c4648832a 100644 --- a/compiler/rust/rust-core/int-overflow-quot/package.json +++ b/compiler/rust/rust-core/int-overflow-quot/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_quot_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_quot_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-quot/provenance.json b/compiler/rust/rust-core/int-overflow-quot/provenance.json index 1a68e7c01..9ba39a5e9 100644 --- a/compiler/rust/rust-core/int-overflow-quot/provenance.json +++ b/compiler/rust/rust-core/int-overflow-quot/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cc2fd98230e16a642ea442c302a3aba183de07236da19c4f4045aecc3d6d2a2f","src/lib.rs":"3b6ab9170264c1df1789a7ceb31c0a9e212514e37416e7caf72b28cf1c1b0402"},"name":"int_overflow_quot_core","profile":"rust-core","program":"1692b3adcca40a04933f6aebc3fea8b84cdd602624476a65e9ba90b04f7b7380","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cc2fd98230e16a642ea442c302a3aba183de07236da19c4f4045aecc3d6d2a2f","src/lib.rs":"3b6ab9170264c1df1789a7ceb31c0a9e212514e37416e7caf72b28cf1c1b0402"},"name":"int_overflow_quot_core","profile":"rust-core","program":"1692b3adcca40a04933f6aebc3fea8b84cdd602624476a65e9ba90b04f7b7380","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-sub/package.json b/compiler/rust/rust-core/int-overflow-sub/package.json index 814156c6e..e60de7069 100644 --- a/compiler/rust/rust-core/int-overflow-sub/package.json +++ b/compiler/rust/rust-core/int-overflow-sub/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_sub_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_sub"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_sub_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_sub"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/int-overflow-sub/provenance.json b/compiler/rust/rust-core/int-overflow-sub/provenance.json index 030fd0e41..c87cc8b18 100644 --- a/compiler/rust/rust-core/int-overflow-sub/provenance.json +++ b/compiler/rust/rust-core/int-overflow-sub/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"897f2fabd3135e24874deb13b076a30dbf0ea55b4b4b976993b7bda85ef5c9d8","src/lib.rs":"aec63756973ebcef39a39f855d2e4b83ee7089d8ac003c7920796ece08b84840"},"name":"int_overflow_sub_core","profile":"rust-core","program":"1e4e6f4192ceb578c2a360bce823d1c1aa01db87a593efa4ac989ee1d3dbb168","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"897f2fabd3135e24874deb13b076a30dbf0ea55b4b4b976993b7bda85ef5c9d8","src/lib.rs":"aec63756973ebcef39a39f855d2e4b83ee7089d8ac003c7920796ece08b84840"},"name":"int_overflow_sub_core","profile":"rust-core","program":"1e4e6f4192ceb578c2a360bce823d1c1aa01db87a593efa4ac989ee1d3dbb168","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate-until-bounded/package.json b/compiler/rust/rust-core/iterate-until-bounded/package.json index 7da9f3352..e21e4a854 100644 --- a/compiler/rust/rust-core/iterate-until-bounded/package.json +++ b/compiler/rust/rust-core/iterate-until-bounded/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_bounded_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_bounded_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate-until-bounded/provenance.json b/compiler/rust/rust-core/iterate-until-bounded/provenance.json index f187d4ef8..a084bbeed 100644 --- a/compiler/rust/rust-core/iterate-until-bounded/provenance.json +++ b/compiler/rust/rust-core/iterate-until-bounded/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"49fbedaa9a76664357097acae248b8fb8152f77f957504442834cbbebe5ad9ed","src/lib.rs":"f39ef7cb1aa9a59c63ccb6c872c7c76b0a896ad4bae77fca0b093a79d338f1c9"},"name":"iterate_until_bounded_core","profile":"rust-core","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"49fbedaa9a76664357097acae248b8fb8152f77f957504442834cbbebe5ad9ed","src/lib.rs":"f39ef7cb1aa9a59c63ccb6c872c7c76b0a896ad4bae77fca0b093a79d338f1c9"},"name":"iterate_until_bounded_core","profile":"rust-core","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate-until/package.json b/compiler/rust/rust-core/iterate-until/package.json index e180621f3..cdea69ca1 100644 --- a/compiler/rust/rust-core/iterate-until/package.json +++ b/compiler/rust/rust-core/iterate-until/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate-until/provenance.json b/compiler/rust/rust-core/iterate-until/provenance.json index 37728a45d..bc9c61b7e 100644 --- a/compiler/rust/rust-core/iterate-until/provenance.json +++ b/compiler/rust/rust-core/iterate-until/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"64ceeab6ac02bc1f724bf26634dddc9f6c506b9867ea9b24ca85874598d484f1","src/lib.rs":"f39ef7cb1aa9a59c63ccb6c872c7c76b0a896ad4bae77fca0b093a79d338f1c9"},"name":"iterate_until_core","profile":"rust-core","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"64ceeab6ac02bc1f724bf26634dddc9f6c506b9867ea9b24ca85874598d484f1","src/lib.rs":"f39ef7cb1aa9a59c63ccb6c872c7c76b0a896ad4bae77fca0b093a79d338f1c9"},"name":"iterate_until_core","profile":"rust-core","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate/package.json b/compiler/rust/rust-core/iterate/package.json index b19dd1b0c..252d7fc1d 100644 --- a/compiler/rust/rust-core/iterate/package.json +++ b/compiler/rust/rust-core/iterate/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/iterate/provenance.json b/compiler/rust/rust-core/iterate/provenance.json index 8802e1119..84006efa9 100644 --- a/compiler/rust/rust-core/iterate/provenance.json +++ b/compiler/rust/rust-core/iterate/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bda30a7b9b61728abe20e4b25ce515e6af98829be9f26ebe4f34cbacc74fd303","src/lib.rs":"8e4a74c1282321b2686519e64b14dbc04fe1fe07bb29743bee99edd5a561788d"},"name":"iterate_core","profile":"rust-core","program":"93495cb93bd9292be524f0e8414d7b827b60f812c842ab717fef46322758cf60","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bda30a7b9b61728abe20e4b25ce515e6af98829be9f26ebe4f34cbacc74fd303","src/lib.rs":"8e4a74c1282321b2686519e64b14dbc04fe1fe07bb29743bee99edd5a561788d"},"name":"iterate_core","profile":"rust-core","program":"93495cb93bd9292be524f0e8414d7b827b60f812c842ab717fef46322758cf60","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/match-shapes/package.json b/compiler/rust/rust-core/match-shapes/package.json index 27f0dc289..0f5e4cc7c 100644 --- a/compiler/rust/rust-core/match-shapes/package.json +++ b/compiler/rust/rust-core/match-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"match_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"bool"}]]}],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[6],"body":{"kind":"build","operands":[{"kind":"var","name":6}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"build","operands":[{"kind":"var","name":7}],"shape":{"kind":"error"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[9],"body":{"kind":"build","operands":[{"kind":"var","name":9}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"compare"}},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[10],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":10},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[11],"body":{"kind":"build","operands":[{"kind":"var","name":11}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[12],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"none"}},{"binders":[13],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"match_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"bool"}]]}],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[6],"body":{"kind":"build","operands":[{"kind":"var","name":6}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"build","operands":[{"kind":"var","name":7}],"shape":{"kind":"error"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[9],"body":{"kind":"build","operands":[{"kind":"var","name":9}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"compare"}},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[10],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":10},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[11],"body":{"kind":"build","operands":[{"kind":"var","name":11}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[12],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"none"}},{"binders":[13],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/match-shapes/provenance.json b/compiler/rust/rust-core/match-shapes/provenance.json index 7f58f8ba3..e65397070 100644 --- a/compiler/rust/rust-core/match-shapes/provenance.json +++ b/compiler/rust/rust-core/match-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6ada04666c2ad8f441c2b0cb866224b03f2fee5fae613a111dd24de4014734fe","src/lib.rs":"9f9fddc2169c8e9193f3f1fdd688dfd06097185e3e634cfbfa620a6f87ba2b9b"},"name":"match_shapes_core","profile":"rust-core","program":"9680443f3a937a999f89648157989a00a6143ddefdeb16329afe27891c3279a2","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6ada04666c2ad8f441c2b0cb866224b03f2fee5fae613a111dd24de4014734fe","src/lib.rs":"9f9fddc2169c8e9193f3f1fdd688dfd06097185e3e634cfbfa620a6f87ba2b9b"},"name":"match_shapes_core","profile":"rust-core","program":"9680443f3a937a999f89648157989a00a6143ddefdeb16329afe27891c3279a2","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-add/package.json b/compiler/rust/rust-core/nat-overflow-add/package.json index 9aede9ee6..8596b4e3d 100644 --- a/compiler/rust/rust-core/nat-overflow-add/package.json +++ b/compiler/rust/rust-core/nat-overflow-add/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_add_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_add_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-add/provenance.json b/compiler/rust/rust-core/nat-overflow-add/provenance.json index 26cf9f62d..ab459fde7 100644 --- a/compiler/rust/rust-core/nat-overflow-add/provenance.json +++ b/compiler/rust/rust-core/nat-overflow-add/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"29d0ecc0775661ad2ef3400d30e5ddabdd011f32e3998989e1b5f92c86cbd3a8","src/lib.rs":"f757bef6232ef38b69895b5d7992f72334ae783bc94dd6b4d76bc726f5c59518"},"name":"nat_overflow_add_core","profile":"rust-core","program":"75136000ad8f2649db77d0237b973fea7740fa9fa28016b113d678a049dc353a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"29d0ecc0775661ad2ef3400d30e5ddabdd011f32e3998989e1b5f92c86cbd3a8","src/lib.rs":"f757bef6232ef38b69895b5d7992f72334ae783bc94dd6b4d76bc726f5c59518"},"name":"nat_overflow_add_core","profile":"rust-core","program":"75136000ad8f2649db77d0237b973fea7740fa9fa28016b113d678a049dc353a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-mul/package.json b/compiler/rust/rust-core/nat-overflow-mul/package.json index ceb70d70b..4016c42ca 100644 --- a/compiler/rust/rust-core/nat-overflow-mul/package.json +++ b/compiler/rust/rust-core/nat-overflow-mul/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_mul_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}}],"operation":{"kind":"nat_mul"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_mul_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}}],"operation":{"kind":"nat_mul"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-mul/provenance.json b/compiler/rust/rust-core/nat-overflow-mul/provenance.json index 31d4d0987..6c430b552 100644 --- a/compiler/rust/rust-core/nat-overflow-mul/provenance.json +++ b/compiler/rust/rust-core/nat-overflow-mul/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b25ad6b1239397b4733e53cc70c9b298a21ee2913c5fa5c2a1fcd13201c933fc","src/lib.rs":"457fcf9b047f518bf2b059d3db569ffab629b48bd0f9cec384881780a351f43f"},"name":"nat_overflow_mul_core","profile":"rust-core","program":"39cd232f7cdf413f7c2ca48cb08a2ba12c63d0e4cad7e882987c21ac7b2ca535","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b25ad6b1239397b4733e53cc70c9b298a21ee2913c5fa5c2a1fcd13201c933fc","src/lib.rs":"457fcf9b047f518bf2b059d3db569ffab629b48bd0f9cec384881780a351f43f"},"name":"nat_overflow_mul_core","profile":"rust-core","program":"39cd232f7cdf413f7c2ca48cb08a2ba12c63d0e4cad7e882987c21ac7b2ca535","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-nested/package.json b/compiler/rust/rust-core/nat-overflow-nested/package.json index 72195d449..9f2286bab 100644 --- a/compiler/rust/rust-core/nat-overflow-nested/package.json +++ b/compiler/rust/rust-core/nat-overflow-nested/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_nested_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_nested_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-nested/provenance.json b/compiler/rust/rust-core/nat-overflow-nested/provenance.json index 4ebe77957..7e2314d2b 100644 --- a/compiler/rust/rust-core/nat-overflow-nested/provenance.json +++ b/compiler/rust/rust-core/nat-overflow-nested/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"879fbc11c0e775e4c2e5f6c7a20f1a767350a14956e43e6e85b974dafee4066e","src/lib.rs":"dc91031bb8617ad6589ca423e0d2164f6e7ec94de5843bb4e93c8b898967913f"},"name":"nat_overflow_nested_core","profile":"rust-core","program":"ce3c27adceeaff5a870453e77162774541aaadbd6163b168d754ee39f964d7f9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"879fbc11c0e775e4c2e5f6c7a20f1a767350a14956e43e6e85b974dafee4066e","src/lib.rs":"dc91031bb8617ad6589ca423e0d2164f6e7ec94de5843bb4e93c8b898967913f"},"name":"nat_overflow_nested_core","profile":"rust-core","program":"ce3c27adceeaff5a870453e77162774541aaadbd6163b168d754ee39f964d7f9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-succ/package.json b/compiler/rust/rust-core/nat-overflow-succ/package.json index 754c2f74c..1e834b7c5 100644 --- a/compiler/rust/rust-core/nat-overflow-succ/package.json +++ b/compiler/rust/rust-core/nat-overflow-succ/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_succ_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_succ_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/nat-overflow-succ/provenance.json b/compiler/rust/rust-core/nat-overflow-succ/provenance.json index 0a81b0850..ca311487b 100644 --- a/compiler/rust/rust-core/nat-overflow-succ/provenance.json +++ b/compiler/rust/rust-core/nat-overflow-succ/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"58be6b46c490679ed7dae3830f6928c2ec1fdc9eeee909b9ee3eee02dfd775d7","src/lib.rs":"8c0612e89cd12bd51bd74666e292dcf87e694b07a9648eba47c5c377647b3c5d"},"name":"nat_overflow_succ_core","profile":"rust-core","program":"71f5809a5001f094afc988a2e7a574309cd425857b135a51fbfeb799e80c9ee5","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"58be6b46c490679ed7dae3830f6928c2ec1fdc9eeee909b9ee3eee02dfd775d7","src/lib.rs":"8c0612e89cd12bd51bd74666e292dcf87e694b07a9648eba47c5c377647b3c5d"},"name":"nat_overflow_succ_core","profile":"rust-core","program":"71f5809a5001f094afc988a2e7a574309cd425857b135a51fbfeb799e80c9ee5","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-goal/package.json b/compiler/rust/rust-core/reasoning-gnaf-goal/package.json index 2931f6cb5..e3b3d30b9 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-goal/package.json +++ b/compiler/rust/rust-core/reasoning-gnaf-goal/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_goal_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_goal_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-goal/provenance.json b/compiler/rust/rust-core/reasoning-gnaf-goal/provenance.json index c3f2ac1db..9e276930f 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-goal/provenance.json +++ b/compiler/rust/rust-core/reasoning-gnaf-goal/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7b54b24663375adbe2e204e2b858f03466ad76d876c5bf352d38b06577139c45","src/lib.rs":"9536fc681dbe92bb11d33af1586fc422d1d3d97255d48335f3125a7a2aa3e2d9"},"name":"reasoning_gnaf_goal_core","profile":"rust-core","program":"3f7539345858c86ded3ea323d38024b3deb6a45c6c7de84927959e23bbf92512","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7b54b24663375adbe2e204e2b858f03466ad76d876c5bf352d38b06577139c45","src/lib.rs":"9536fc681dbe92bb11d33af1586fc422d1d3d97255d48335f3125a7a2aa3e2d9"},"name":"reasoning_gnaf_goal_core","profile":"rust-core","program":"3f7539345858c86ded3ea323d38024b3deb6a45c6c7de84927959e23bbf92512","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-priority/package.json b/compiler/rust/rust-core/reasoning-gnaf-priority/package.json index 90d599a90..0a7a6e195 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-priority/package.json +++ b/compiler/rust/rust-core/reasoning-gnaf-priority/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_priority_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_priority_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-priority/provenance.json b/compiler/rust/rust-core/reasoning-gnaf-priority/provenance.json index 221e1f9b9..138abaaf0 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-priority/provenance.json +++ b/compiler/rust/rust-core/reasoning-gnaf-priority/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3535efab36ca3a8d39c5976323811badc0280578bae597a2a714624ac29213ed","src/lib.rs":"662506d0fad69b47183b300a4bc3b1ccd93b140a207a78e3cd6e49cd6b69f1c3"},"name":"reasoning_gnaf_priority_core","profile":"rust-core","program":"3daf7454a6bd393de7d12ecf49636d2914d09cec5748ae837b7684e00b95fe74","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3535efab36ca3a8d39c5976323811badc0280578bae597a2a714624ac29213ed","src/lib.rs":"662506d0fad69b47183b300a4bc3b1ccd93b140a207a78e3cd6e49cd6b69f1c3"},"name":"reasoning_gnaf_priority_core","profile":"rust-core","program":"3daf7454a6bd393de7d12ecf49636d2914d09cec5748ae837b7684e00b95fe74","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-sweep/package.json b/compiler/rust/rust-core/reasoning-gnaf-sweep/package.json index 6f55c743e..d268b3d32 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-sweep/package.json +++ b/compiler/rust/rust-core/reasoning-gnaf-sweep/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_sweep_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_sweep_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-gnaf-sweep/provenance.json b/compiler/rust/rust-core/reasoning-gnaf-sweep/provenance.json index 824f18d96..6b0421e0b 100644 --- a/compiler/rust/rust-core/reasoning-gnaf-sweep/provenance.json +++ b/compiler/rust/rust-core/reasoning-gnaf-sweep/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"841bb00629c7ce887e593e1e6ae9fe3e5a14c38e059b93ac1b676f122a621666","src/lib.rs":"3c51fb6124e3bcf7cccc2bf6bb9c7a3b9d40b3a4d51bb35511faab4eef723f2f"},"name":"reasoning_gnaf_sweep_core","profile":"rust-core","program":"ed0eba6159b16bcdf765c6e275fceab30b7c9c1b6470f4a19bb09a92a79e19f4","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"841bb00629c7ce887e593e1e6ae9fe3e5a14c38e059b93ac1b676f122a621666","src/lib.rs":"3c51fb6124e3bcf7cccc2bf6bb9c7a3b9d40b3a4d51bb35511faab4eef723f2f"},"name":"reasoning_gnaf_sweep_core","profile":"rust-core","program":"ed0eba6159b16bcdf765c6e275fceab30b7c9c1b6470f4a19bb09a92a79e19f4","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-grade-shock/package.json b/compiler/rust/rust-core/reasoning-grade-shock/package.json index f0bf7dcf3..cf440fc94 100644 --- a/compiler/rust/rust-core/reasoning-grade-shock/package.json +++ b/compiler/rust/rust-core/reasoning-grade-shock/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_shock_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_shock_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-grade-shock/provenance.json b/compiler/rust/rust-core/reasoning-grade-shock/provenance.json index ba730a196..254fecc48 100644 --- a/compiler/rust/rust-core/reasoning-grade-shock/provenance.json +++ b/compiler/rust/rust-core/reasoning-grade-shock/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"281173f36bdfa7c25b07a935ce271f8b0ae236e179794ef4b702920bb7e9a5e0","src/lib.rs":"8983f815a05c87426498b43886fd1fbe05c24d4ff63fd5451ecf8e5c1477b02d"},"name":"reasoning_grade_shock_core","profile":"rust-core","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"281173f36bdfa7c25b07a935ce271f8b0ae236e179794ef4b702920bb7e9a5e0","src/lib.rs":"8983f815a05c87426498b43886fd1fbe05c24d4ff63fd5451ecf8e5c1477b02d"},"name":"reasoning_grade_shock_core","profile":"rust-core","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-grade-well/package.json b/compiler/rust/rust-core/reasoning-grade-well/package.json index 75ce56b1e..49d2b6fed 100644 --- a/compiler/rust/rust-core/reasoning-grade-well/package.json +++ b/compiler/rust/rust-core/reasoning-grade-well/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_well_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_well_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-grade-well/provenance.json b/compiler/rust/rust-core/reasoning-grade-well/provenance.json index 90b530e67..cdf9c9589 100644 --- a/compiler/rust/rust-core/reasoning-grade-well/provenance.json +++ b/compiler/rust/rust-core/reasoning-grade-well/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"851436668cd106d5db562e51def9d73a253b9c18ed0dfa27aa96f479c18e1b9e","src/lib.rs":"8983f815a05c87426498b43886fd1fbe05c24d4ff63fd5451ecf8e5c1477b02d"},"name":"reasoning_grade_well_core","profile":"rust-core","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"851436668cd106d5db562e51def9d73a253b9c18ed0dfa27aa96f479c18e1b9e","src/lib.rs":"8983f815a05c87426498b43886fd1fbe05c24d4ff63fd5451ecf8e5c1477b02d"},"name":"reasoning_grade_well_core","profile":"rust-core","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-review-exhausted/package.json b/compiler/rust/rust-core/reasoning-review-exhausted/package.json index 0a4d3e369..e09bc45ae 100644 --- a/compiler/rust/rust-core/reasoning-review-exhausted/package.json +++ b/compiler/rust/rust-core/reasoning-review-exhausted/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_exhausted_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_exhausted_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-review-exhausted/provenance.json b/compiler/rust/rust-core/reasoning-review-exhausted/provenance.json index c04e7c8bc..2a33d06f8 100644 --- a/compiler/rust/rust-core/reasoning-review-exhausted/provenance.json +++ b/compiler/rust/rust-core/reasoning-review-exhausted/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"998f44193d50ca3cc6bfbad743b1f4aaef06513fea5b7f45ca0124f521e60619","src/lib.rs":"05ba28812d2ee0e599163d3596f0f1a43eaad683b717f58294702298a7ad4da9"},"name":"reasoning_review_exhausted_core","profile":"rust-core","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"998f44193d50ca3cc6bfbad743b1f4aaef06513fea5b7f45ca0124f521e60619","src/lib.rs":"05ba28812d2ee0e599163d3596f0f1a43eaad683b717f58294702298a7ad4da9"},"name":"reasoning_review_exhausted_core","profile":"rust-core","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-review-rejected/package.json b/compiler/rust/rust-core/reasoning-review-rejected/package.json index e030d7e3c..63cef39d5 100644 --- a/compiler/rust/rust-core/reasoning-review-rejected/package.json +++ b/compiler/rust/rust-core/reasoning-review-rejected/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_rejected_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_rejected_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-review-rejected/provenance.json b/compiler/rust/rust-core/reasoning-review-rejected/provenance.json index bd1ab7c5a..22fa64acb 100644 --- a/compiler/rust/rust-core/reasoning-review-rejected/provenance.json +++ b/compiler/rust/rust-core/reasoning-review-rejected/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"021fdd34c74ecae0c6c5792782b294011079c531ccff83ee06a83e8c496f5bf0","src/lib.rs":"05ba28812d2ee0e599163d3596f0f1a43eaad683b717f58294702298a7ad4da9"},"name":"reasoning_review_rejected_core","profile":"rust-core","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"021fdd34c74ecae0c6c5792782b294011079c531ccff83ee06a83e8c496f5bf0","src/lib.rs":"05ba28812d2ee0e599163d3596f0f1a43eaad683b717f58294702298a7ad4da9"},"name":"reasoning_review_rejected_core","profile":"rust-core","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-triage-shock/package.json b/compiler/rust/rust-core/reasoning-triage-shock/package.json index e93e0069c..341f92b7f 100644 --- a/compiler/rust/rust-core/reasoning-triage-shock/package.json +++ b/compiler/rust/rust-core/reasoning-triage-shock/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_shock_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_shock_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-triage-shock/provenance.json b/compiler/rust/rust-core/reasoning-triage-shock/provenance.json index c8380afb5..b9c11fa39 100644 --- a/compiler/rust/rust-core/reasoning-triage-shock/provenance.json +++ b/compiler/rust/rust-core/reasoning-triage-shock/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e04326cfaee916a459127b3b48ef9fe3a013a40c628024431d49e6ff034339c4","src/lib.rs":"08a4c05a0f77186244b6e3021c578fc3771c866bc17dc3eb795c46e422db2f23"},"name":"reasoning_triage_shock_core","profile":"rust-core","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e04326cfaee916a459127b3b48ef9fe3a013a40c628024431d49e6ff034339c4","src/lib.rs":"08a4c05a0f77186244b6e3021c578fc3771c866bc17dc3eb795c46e422db2f23"},"name":"reasoning_triage_shock_core","profile":"rust-core","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-triage-well/package.json b/compiler/rust/rust-core/reasoning-triage-well/package.json index dd6f489c9..8bcd23b2f 100644 --- a/compiler/rust/rust-core/reasoning-triage-well/package.json +++ b/compiler/rust/rust-core/reasoning-triage-well/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_well_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_well_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/reasoning-triage-well/provenance.json b/compiler/rust/rust-core/reasoning-triage-well/provenance.json index 705edba20..b646667e9 100644 --- a/compiler/rust/rust-core/reasoning-triage-well/provenance.json +++ b/compiler/rust/rust-core/reasoning-triage-well/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fec28bf9de2addfa3bf3ce9f515185851e543bd16000fabdd5bbbe665c9c0e9c","src/lib.rs":"08a4c05a0f77186244b6e3021c578fc3771c866bc17dc3eb795c46e422db2f23"},"name":"reasoning_triage_well_core","profile":"rust-core","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fec28bf9de2addfa3bf3ce9f515185851e543bd16000fabdd5bbbe665c9c0e9c","src/lib.rs":"08a4c05a0f77186244b6e3021c578fc3771c866bc17dc3eb795c46e422db2f23"},"name":"reasoning_triage_well_core","profile":"rust-core","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/record-fields/package.json b/compiler/rust/rust-core/record-fields/package.json index 831f00fb0..a6a33db18 100644 --- a/compiler/rust/rust-core/record-fields/package.json +++ b/compiler/rust/rust-core/record-fields/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"record_fields_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"record_fields_core","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/record-fields/provenance.json b/compiler/rust/rust-core/record-fields/provenance.json index 2d62fc290..c10e5a224 100644 --- a/compiler/rust/rust-core/record-fields/provenance.json +++ b/compiler/rust/rust-core/record-fields/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ec4cee195074d69882a3f6e5e4bbf6de21dfbfec8722c213645e22b9b6a499b9","src/lib.rs":"bce72d4976ac1979220d1076143a53904f169dcedb4992441f9aa24c38b97352"},"name":"record_fields_core","profile":"rust-core","program":"526bb181b433435ecf3b9116937f342406bd8db3d26cc26b870d03e7f3c11ca9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ec4cee195074d69882a3f6e5e4bbf6de21dfbfec8722c213645e22b9b6a499b9","src/lib.rs":"bce72d4976ac1979220d1076143a53904f169dcedb4992441f9aa24c38b97352"},"name":"record_fields_core","profile":"rust-core","program":"526bb181b433435ecf3b9116937f342406bd8db3d26cc26b870d03e7f3c11ca9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/sum-to-exhausted/package.json b/compiler/rust/rust-core/sum-to-exhausted/package.json index 5a86679a9..453361ee5 100644 --- a/compiler/rust/rust-core/sum-to-exhausted/package.json +++ b/compiler/rust/rust-core/sum-to-exhausted/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_exhausted_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_exhausted_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/sum-to-exhausted/provenance.json b/compiler/rust/rust-core/sum-to-exhausted/provenance.json index 100f2bdc1..4e53570a4 100644 --- a/compiler/rust/rust-core/sum-to-exhausted/provenance.json +++ b/compiler/rust/rust-core/sum-to-exhausted/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bac87758ae0145c960c00f8badc41eac7c8a85900f4472616b4aa784f4bfebb4","src/lib.rs":"534c18643ecfdfdb6864809e6d39bf903946b2d2a50f8d68028eaa8fb5ec42a0"},"name":"sum_to_exhausted_core","profile":"rust-core","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bac87758ae0145c960c00f8badc41eac7c8a85900f4472616b4aa784f4bfebb4","src/lib.rs":"534c18643ecfdfdb6864809e6d39bf903946b2d2a50f8d68028eaa8fb5ec42a0"},"name":"sum_to_exhausted_core","profile":"rust-core","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/sum-to/package.json b/compiler/rust/rust-core/sum-to/package.json index fdab71444..60148184b 100644 --- a/compiler/rust/rust-core/sum-to/package.json +++ b/compiler/rust/rust-core/sum-to/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/sum-to/provenance.json b/compiler/rust/rust-core/sum-to/provenance.json index cfbe30703..75b8f2b29 100644 --- a/compiler/rust/rust-core/sum-to/provenance.json +++ b/compiler/rust/rust-core/sum-to/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6a8011ffd55c1c68e8ffe52afb89c94f028e906fe02f9ee5d79f7db3d619f6e0","src/lib.rs":"534c18643ecfdfdb6864809e6d39bf903946b2d2a50f8d68028eaa8fb5ec42a0"},"name":"sum_to_core","profile":"rust-core","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6a8011ffd55c1c68e8ffe52afb89c94f028e906fe02f9ee5d79f7db3d619f6e0","src/lib.rs":"534c18643ecfdfdb6864809e6d39bf903946b2d2a50f8d68028eaa8fb5ec42a0"},"name":"sum_to_core","profile":"rust-core","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/unit-closures/package.json b/compiler/rust/rust-core/unit-closures/package.json index a53e2cb3f..a1f5b80bb 100644 --- a/compiler/rust/rust-core/unit-closures/package.json +++ b/compiler/rust/rust-core/unit-closures/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"unit_closures_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"unit"}},{"kind":"nat"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"unit_closures_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"unit"}},{"kind":"nat"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/unit-closures/provenance.json b/compiler/rust/rust-core/unit-closures/provenance.json index bb64a08d6..12963cf27 100644 --- a/compiler/rust/rust-core/unit-closures/provenance.json +++ b/compiler/rust/rust-core/unit-closures/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a191efaef909a589104c2eaa34cabd3d20c7a4938cba92935d2a5a28ea898044","src/lib.rs":"ef8a474329bc8d587ec4d72ae082da03fd98bf5bf9bdb2185ebd7820843d973c"},"name":"unit_closures_core","profile":"rust-core","program":"e2f55254e66e933625b9a18c2414242a0f3a55dccef58b663673c4027a619c34","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a191efaef909a589104c2eaa34cabd3d20c7a4938cba92935d2a5a28ea898044","src/lib.rs":"ef8a474329bc8d587ec4d72ae082da03fd98bf5bf9bdb2185ebd7820843d973c"},"name":"unit_closures_core","profile":"rust-core","program":"e2f55254e66e933625b9a18c2414242a0f3a55dccef58b663673c4027a619c34","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/unit-values/package.json b/compiler/rust/rust-core/unit-values/package.json index 14d0f4b5c..47685d3ed 100644 --- a/compiler/rust/rust-core/unit-values/package.json +++ b/compiler/rust/rust-core/unit-values/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"unit_values_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}}},"bound":{"function":5,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}}]},"kind":"let","name":4,"type":{"kind":"unit"}},"bound":{"function":4,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":3,"type":{"kind":"unit"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":2,"type":{"kind":"unit"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"unit"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}]}}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"unit_values_core","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}}},"bound":{"function":5,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}}]},"kind":"let","name":4,"type":{"kind":"unit"}},"bound":{"function":4,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":3,"type":{"kind":"unit"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":2,"type":{"kind":"unit"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"unit"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}]}}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/unit-values/provenance.json b/compiler/rust/rust-core/unit-values/provenance.json index d1e07b99b..942e6fb8a 100644 --- a/compiler/rust/rust-core/unit-values/provenance.json +++ b/compiler/rust/rust-core/unit-values/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"61e5f6497df7d1aea5341af494e12a23d168d9b415043427c7f081e7bae06fee","src/lib.rs":"eaa59c524f3c4b03f5f86c540e3b5469b53df5714e5e8d64f754654f53fc49d2"},"name":"unit_values_core","profile":"rust-core","program":"da46c33882a69c2a5bed667c6e026399692e7ebc318523c341cef90e9257d9ea","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"61e5f6497df7d1aea5341af494e12a23d168d9b415043427c7f081e7bae06fee","src/lib.rs":"eaa59c524f3c4b03f5f86c540e3b5469b53df5714e5e8d64f754654f53fc49d2"},"name":"unit_values_core","profile":"rust-core","program":"da46c33882a69c2a5bed667c6e026399692e7ebc318523c341cef90e9257d9ea","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/wide-shapes/package.json b/compiler/rust/rust-core/wide-shapes/package.json index 650d28534..5b1845fbf 100644 --- a/compiler/rust/rust-core/wide-shapes/package.json +++ b/compiler/rust/rust-core/wide-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"wide_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[],[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":7},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2,3,4,5,6,7],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"wide_shapes_core","profile":"rust-core","program":{"adts":[{"constructors":[[],[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":7},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2,3,4,5,6,7],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-core/wide-shapes/provenance.json b/compiler/rust/rust-core/wide-shapes/provenance.json index 7e870b189..606db945b 100644 --- a/compiler/rust/rust-core/wide-shapes/provenance.json +++ b/compiler/rust/rust-core/wide-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a5d6d54e6cd75aa85e08ca3fa3f4083d046d682328f6e35595b14ef3c3d6724e","src/lib.rs":"ba61f4e116c8681cf54f92be37833831410972ce4cbe87a0ee16749178b494cd"},"name":"wide_shapes_core","profile":"rust-core","program":"d0de8fa403502aaf54be1ccfae31401db4a92de6aa9ae953b340395fe2de28ec","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a5d6d54e6cd75aa85e08ca3fa3f4083d046d682328f6e35595b14ef3c3d6724e","src/lib.rs":"ba61f4e116c8681cf54f92be37833831410972ce4cbe87a0ee16749178b494cd"},"name":"wide_shapes_core","profile":"rust-core","program":"d0de8fa403502aaf54be1ccfae31401db4a92de6aa9ae953b340395fe2de28ec","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/adt-evaluation/package.json b/compiler/rust/rust-std/adt-evaluation/package.json index 35e2fe0a4..cca015a9c 100644 --- a/compiler/rust/rust-std/adt-evaluation/package.json +++ b/compiler/rust/rust-std/adt-evaluation/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":[]}],"name":"adt_evaluation_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":0,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":4}},{"index":1,"kind":"field","value":{"kind":"var","name":4}}],"operation":{"kind":"nat_add"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"function":0,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":1,"name":"run","parameters":[]}],"name":"adt_evaluation_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":0,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":4}},{"index":1,"kind":"field","value":{"kind":"var","name":4}}],"operation":{"kind":"nat_add"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"function":0,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/adt-evaluation/provenance.json b/compiler/rust/rust-std/adt-evaluation/provenance.json index b1b4890c0..6b752cfd4 100644 --- a/compiler/rust/rust-std/adt-evaluation/provenance.json +++ b/compiler/rust/rust-std/adt-evaluation/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":1,"name":"run"}],"files":{"Cargo.toml":"c75702ca27cc592448af8c7d1d90d22fef746dc99342a5c720b38656aa722105","src/lib.rs":"10390762c4bbf72b815eb8895a8e5490cfbc4b1e8a58bc6febb5618961f11fb4"},"name":"adt_evaluation_std","profile":"rust-std","program":"c573271cec93dbc40bebdbbe9002fadeade7cb1d7821a5f52ec1ddbca9e2b836","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":1,"name":"run"}],"files":{"Cargo.toml":"c75702ca27cc592448af8c7d1d90d22fef746dc99342a5c720b38656aa722105","src/lib.rs":"10390762c4bbf72b815eb8895a8e5490cfbc4b1e8a58bc6febb5618961f11fb4"},"name":"adt_evaluation_std","profile":"rust-std","program":"c573271cec93dbc40bebdbbe9002fadeade7cb1d7821a5f52ec1ddbca9e2b836","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/binding-and-shapes/package.json b/compiler/rust/rust-std/binding-and-shapes/package.json index d7e57d82d..9bfddbba8 100644 --- a/compiler/rust/rust-std/binding-and-shapes/package.json +++ b/compiler/rust/rust-std/binding-and-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"binding_and_shapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":1}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[4],"body":{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ok"}},"shape":{"kind":"ok"}},{"binders":[5],"body":{"kind":"var","name":5},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}}},"type":{"kind":"string"}},{"arms":[{"binders":[],"body":{"arms":[{"binders":[6],"body":{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ok"}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"var","name":7},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"failed"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}}},"type":{"kind":"string"}},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"type":{"kind":"string"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}}},"bound":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"let","name":2,"type":{"kind":"option","value":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"left"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},"kind":"let","name":1,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"binding_and_shapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":1}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[4],"body":{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ok"}},"shape":{"kind":"ok"}},{"binders":[5],"body":{"kind":"var","name":5},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}}},"type":{"kind":"string"}},{"arms":[{"binders":[],"body":{"arms":[{"binders":[6],"body":{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ok"}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"var","name":7},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"failed"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}}},"type":{"kind":"string"}},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"type":{"kind":"string"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}}},"bound":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"let","name":2,"type":{"kind":"option","value":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"left"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},"kind":"let","name":1,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/binding-and-shapes/provenance.json b/compiler/rust/rust-std/binding-and-shapes/provenance.json index a2595ddf8..404533f38 100644 --- a/compiler/rust/rust-std/binding-and-shapes/provenance.json +++ b/compiler/rust/rust-std/binding-and-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f7ec8b673a50007f2518189f48be5d0c87cbd3d4c9b3bca9d5435388ac9b1929","src/lib.rs":"66485d61c9126e0538d619f5254125b6257c6bae07a9d7e9c35506062544c501"},"name":"binding_and_shapes_std","profile":"rust-std","program":"03bfd0349c88b8cb299f4a49adf5370e43e53e319b3ea8cc32bc9c15c9b6b54f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f7ec8b673a50007f2518189f48be5d0c87cbd3d4c9b3bca9d5435388ac9b1929","src/lib.rs":"66485d61c9126e0538d619f5254125b6257c6bae07a9d7e9c35506062544c501"},"name":"binding_and_shapes_std","profile":"rust-std","program":"03bfd0349c88b8cb299f4a49adf5370e43e53e319b3ea8cc32bc9c15c9b6b54f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/boolean-shapes/package.json b/compiler/rust/rust-std/boolean-shapes/package.json index 477475233..81745b49c 100644 --- a/compiler/rust/rust-std/boolean-shapes/package.json +++ b/compiler/rust/rust-std/boolean-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"boolean_shapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"condition":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"zero"}},{"binders":[5],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}},"types":[{"kind":"bool"},{"kind":"bool"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"boolean_shapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},{"kind":"build","operands":[{"condition":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"zero"}},{"binders":[5],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}}},"types":[{"kind":"bool"},{"kind":"bool"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/boolean-shapes/provenance.json b/compiler/rust/rust-std/boolean-shapes/provenance.json index e5522695b..1c06bd8fa 100644 --- a/compiler/rust/rust-std/boolean-shapes/provenance.json +++ b/compiler/rust/rust-std/boolean-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"27f4b6d8ea06bd40796ffb2da18b034f66ac5dbe717d22914d0e3ee60c18c66c","src/lib.rs":"40841d1a8fd88a1bb0e013dbe131d7e5879b5e209a1654279dd1f35357cbed26"},"name":"boolean_shapes_std","profile":"rust-std","program":"08c54665d09d55ac525712aaf1c9be1ab4a4335c07dcc89b2bc107f4e151e2c9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"27f4b6d8ea06bd40796ffb2da18b034f66ac5dbe717d22914d0e3ee60c18c66c","src/lib.rs":"40841d1a8fd88a1bb0e013dbe131d7e5879b5e209a1654279dd1f35357cbed26"},"name":"boolean_shapes_std","profile":"rust-std","program":"08c54665d09d55ac525712aaf1c9be1ab4a4335c07dcc89b2bc107f4e151e2c9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/booleans/package.json b/compiler/rust/rust-std/booleans/package.json index 69ea979f4..11f5c0ef6 100644 --- a/compiler/rust/rust-std/booleans/package.json +++ b/compiler/rust/rust-std/booleans/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"booleans_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"booleans_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"true"}},{"binders":[],"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bool_not"}},"shape":{"kind":"false"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/booleans/provenance.json b/compiler/rust/rust-std/booleans/provenance.json index 776df9b4f..0aa66ae7a 100644 --- a/compiler/rust/rust-std/booleans/provenance.json +++ b/compiler/rust/rust-std/booleans/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4197743b8008a08e062227c578c44fd3fb12b2377e05378e0613c2c63dab15da","src/lib.rs":"cf1e99037d3f9d080d1ce4e8706e38ab339279d5d7e803cc641916759b7763da"},"name":"booleans_std","profile":"rust-std","program":"df569820e9e36f6ecd0c9ad30a82b24e02db81757db33e6c0789609ea89bdbab","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4197743b8008a08e062227c578c44fd3fb12b2377e05378e0613c2c63dab15da","src/lib.rs":"cf1e99037d3f9d080d1ce4e8706e38ab339279d5d7e803cc641916759b7763da"},"name":"booleans_std","profile":"rust-std","program":"df569820e9e36f6ecd0c9ad30a82b24e02db81757db33e6c0789609ea89bdbab","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/boxed-field/package.json b/compiler/rust/rust-std/boxed-field/package.json index f7e7b03f0..9d8fb56ef 100644 --- a/compiler/rust/rust-std/boxed-field/package.json +++ b/compiler/rust/rust-std/boxed-field/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"boxed_field_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"option","value":{"index":0,"kind":"adt"}}]]}],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"boxed_field_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"option","value":{"index":0,"kind":"adt"}}]]}],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/boxed-field/provenance.json b/compiler/rust/rust-std/boxed-field/provenance.json index 79c974de2..ed5548a69 100644 --- a/compiler/rust/rust-std/boxed-field/provenance.json +++ b/compiler/rust/rust-std/boxed-field/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cc0862b3a8ee27dbce70b00690d265640d4a1703f4b4398739a97970461c6f01","src/lib.rs":"ddece29562ad1947f5534fb5b422f25e96b9b9b7f625fd0438638120215acfa3"},"name":"boxed_field_std","profile":"rust-std","program":"51b72a735ab4653f0b06e46b13240e830423df152d765b1b3e5000727e7a8728","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cc0862b3a8ee27dbce70b00690d265640d4a1703f4b4398739a97970461c6f01","src/lib.rs":"ddece29562ad1947f5534fb5b422f25e96b9b9b7f625fd0438638120215acfa3"},"name":"boxed_field_std","profile":"rust-std","program":"51b72a735ab4653f0b06e46b13240e830423df152d765b1b3e5000727e7a8728","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-compare/package.json b/compiler/rust/rust-std/byte-compare/package.json index a1a0fe20e..d5f92234b 100644 --- a/compiler/rust/rust-std/byte-compare/package.json +++ b/compiler/rust/rust-std/byte-compare/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_compare_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0102","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0103","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a0b","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a0b","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"ordering"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_compare_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0102","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0103","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a0b","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a0b","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"ordering"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-compare/provenance.json b/compiler/rust/rust-std/byte-compare/provenance.json index afe344801..d6f8c9ba5 100644 --- a/compiler/rust/rust-std/byte-compare/provenance.json +++ b/compiler/rust/rust-std/byte-compare/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1685888a79754795f2c3d730e7c284c74027d3bfc41dd450b78cad1e03d4105e","src/lib.rs":"33be023ea6962ac6e6c85247e6f48f02a629963c6447294648c76d9345db263b"},"name":"byte_compare_std","profile":"rust-std","program":"d48f6f4d3b00001f687ef861c922a17e1d1ea6f22bc87f2eba0315b790bbcb78","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1685888a79754795f2c3d730e7c284c74027d3bfc41dd450b78cad1e03d4105e","src/lib.rs":"33be023ea6962ac6e6c85247e6f48f02a629963c6447294648c76d9345db263b"},"name":"byte_compare_std","profile":"rust-std","program":"d48f6f4d3b00001f687ef861c922a17e1d1ea6f22bc87f2eba0315b790bbcb78","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-order/package.json b/compiler/rust/rust-std/byte-order/package.json index 460e56731..6fbc3780d 100644 --- a/compiler/rust/rust-std/byte-order/package.json +++ b/compiler/rust/rust-std/byte-order/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_order_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00fe","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"02","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"hé€"}}],"operation":{"kind":"utf8_encode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0100","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0100","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"bool"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"bool"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_order_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00fe","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"02","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"hé€"}}],"operation":{"kind":"utf8_encode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0100","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0100","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"bool"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"bool"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"ordering"},"kind":"list"}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-order/provenance.json b/compiler/rust/rust-std/byte-order/provenance.json index b0083dbf7..606a74093 100644 --- a/compiler/rust/rust-std/byte-order/provenance.json +++ b/compiler/rust/rust-std/byte-order/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"929bf7f4536e35e0c45ec5138a10d02b53bfc4e9bc9cbb2c5808e8e9aaa4051a","src/lib.rs":"63428c562c0f57a11f31de57cc06086a888403bba505548b007317e542254f43"},"name":"byte_order_std","profile":"rust-std","program":"58df17f0cb505de9d250d998d4f5f43ba6e1e90ad88feea2eea1667aaa80495a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"929bf7f4536e35e0c45ec5138a10d02b53bfc4e9bc9cbb2c5808e8e9aaa4051a","src/lib.rs":"63428c562c0f57a11f31de57cc06086a888403bba505548b007317e542254f43"},"name":"byte_order_std","profile":"rust-std","program":"58df17f0cb505de9d250d998d4f5f43ba6e1e90ad88feea2eea1667aaa80495a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-slices/package.json b/compiler/rust/rust-std/byte-slices/package.json index 02e530289..8658c2451 100644 --- a/compiler/rust/rust-std/byte-slices/package.json +++ b/compiler/rust/rust-std/byte-slices/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_slices_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"byte_slices_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00112233","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"option","value":{"kind":"bytes"}},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/byte-slices/provenance.json b/compiler/rust/rust-std/byte-slices/provenance.json index 7e78a84df..c9bf972ed 100644 --- a/compiler/rust/rust-std/byte-slices/provenance.json +++ b/compiler/rust/rust-std/byte-slices/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3a8a7c456c3309edccaea0c3543cd0211401e43fdf6cd3e626763123ddd45743","src/lib.rs":"19ea90f565cb047055c05e8c1af6944b0e3341d21fc02cb0bfaa7ddf9cc193e6"},"name":"byte_slices_std","profile":"rust-std","program":"db383c532849c59ce08e51c7905d23385c122dd7ee30de0e6e56fdc2d9ebba33","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3a8a7c456c3309edccaea0c3543cd0211401e43fdf6cd3e626763123ddd45743","src/lib.rs":"19ea90f565cb047055c05e8c1af6944b0e3341d21fc02cb0bfaa7ddf9cc193e6"},"name":"byte_slices_std","profile":"rust-std","program":"db383c532849c59ce08e51c7905d23385c122dd7ee30de0e6e56fdc2d9ebba33","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/bytes-and-text/package.json b/compiler/rust/rust-std/bytes-and-text/package.json index accc0cfa5..beed6a2b0 100644 --- a/compiler/rust/rust-std/bytes-and-text/package.json +++ b/compiler/rust/rust-std/bytes-and-text/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"bytes_and_text_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0102","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"010203","kind":"bytes"}}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"héllo€"}}],"operation":{"kind":"length"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0aff","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0aff","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"68c3a9","kind":"bytes"}}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"c328","kind":"bytes"}}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"bytes_and_text_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0102","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"ff","kind":"bytes"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"010203","kind":"bytes"}}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"héllo€"}}],"operation":{"kind":"length"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0aff","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0aff","kind":"bytes"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"68c3a9","kind":"bytes"}}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"c328","kind":"bytes"}}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"string"}},"kind":"list"}}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/bytes-and-text/provenance.json b/compiler/rust/rust-std/bytes-and-text/provenance.json index a785023f4..a2fef6714 100644 --- a/compiler/rust/rust-std/bytes-and-text/provenance.json +++ b/compiler/rust/rust-std/bytes-and-text/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4d0cfb5ef3ce72b9fd8cfe426f60ee8c75c7d554746aab9bb334391618f42ce7","src/lib.rs":"2efa4fcdc45d46335320ca258257e94adfd4718f78f1d13243f8e8a105ddd3ee"},"name":"bytes_and_text_std","profile":"rust-std","program":"90c512537d4f85ae493b4d8df30d97811078d055c0b69a120949ed63053e089e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4d0cfb5ef3ce72b9fd8cfe426f60ee8c75c7d554746aab9bb334391618f42ce7","src/lib.rs":"2efa4fcdc45d46335320ca258257e94adfd4718f78f1d13243f8e8a105ddd3ee"},"name":"bytes_and_text_std","profile":"rust-std","program":"90c512537d4f85ae493b4d8df30d97811078d055c0b69a120949ed63053e089e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-captures/package.json b/compiler/rust/rust-std/closure-captures/package.json index 44d235ba0..1cade2cf0 100644 --- a/compiler/rust/rust-std/closure-captures/package.json +++ b/compiler/rust/rust-std/closure-captures/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"closure_captures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"closure_captures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-captures/provenance.json b/compiler/rust/rust-std/closure-captures/provenance.json index a88c78ee8..5e9d52a76 100644 --- a/compiler/rust/rust-std/closure-captures/provenance.json +++ b/compiler/rust/rust-std/closure-captures/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c0f4ab7556534e9d6bcc971dc361820251d3127ce9d387d02227c6d97747350e","src/lib.rs":"88b362fc18cc7bb954a76f869ca5dcd8723fa11aeefd5a0b986ab136132d7a40"},"name":"closure_captures_std","profile":"rust-std","program":"e2d52d5414c5f9639f8e127b054cd3820f186da100f2dd2c1b707805abba379f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c0f4ab7556534e9d6bcc971dc361820251d3127ce9d387d02227c6d97747350e","src/lib.rs":"88b362fc18cc7bb954a76f869ca5dcd8723fa11aeefd5a0b986ab136132d7a40"},"name":"closure_captures_std","profile":"rust-std","program":"e2d52d5414c5f9639f8e127b054cd3820f186da100f2dd2c1b707805abba379f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-dispatch/package.json b/compiler/rust/rust-std/closure-dispatch/package.json index e9819762b..d76680eea 100644 --- a/compiler/rust/rust-std/closure-dispatch/package.json +++ b/compiler/rust/rust-std/closure-dispatch/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_dispatch_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}]},{"function":3,"kind":"call","operands":[{"captures":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"function":2,"kind":"closure"},{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"string"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"string"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_dispatch_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}]},{"function":3,"kind":"call","operands":[{"captures":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"function":2,"kind":"closure"},{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"string"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"string"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-dispatch/provenance.json b/compiler/rust/rust-std/closure-dispatch/provenance.json index 3c25c198f..0c16feec6 100644 --- a/compiler/rust/rust-std/closure-dispatch/provenance.json +++ b/compiler/rust/rust-std/closure-dispatch/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9baf4aaaf363171f1ee359cc787061e8f3b838a40f496da53d3ef3d2e27afd45","src/lib.rs":"4ebcb07a381642994ce7721d5b2b0ba5a812addc835f88b566112388dd234188"},"name":"closure_dispatch_std","profile":"rust-std","program":"2c8491e46d4c4170f5f7e314245c304d91dc7cc4401639794e0057c1fbf4ff3e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9baf4aaaf363171f1ee359cc787061e8f3b838a40f496da53d3ef3d2e27afd45","src/lib.rs":"4ebcb07a381642994ce7721d5b2b0ba5a812addc835f88b566112388dd234188"},"name":"closure_dispatch_std","profile":"rust-std","program":"2c8491e46d4c4170f5f7e314245c304d91dc7cc4401639794e0057c1fbf4ff3e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-inline/package.json b/compiler/rust/rust-std/closure-inline/package.json index ef4a68c93..1c14b3914 100644 --- a/compiler/rust/rust-std/closure-inline/package.json +++ b/compiler/rust/rust-std/closure-inline/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_inline_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}],"target":{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closure_inline_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"apply","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}],"target":{"captures":[{"kind":"var","name":0},{"kind":"var","name":1}],"function":1,"kind":"closure"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-inline/provenance.json b/compiler/rust/rust-std/closure-inline/provenance.json index ebbd9d5e0..74c9ad89b 100644 --- a/compiler/rust/rust-std/closure-inline/provenance.json +++ b/compiler/rust/rust-std/closure-inline/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5b5cb8b712efe50f580de93fe24776f3dfbaaa75efcefb60afb85aeb265f99d2","src/lib.rs":"938d07d0745e3d9be6f051487ba58a8ccc9d2c0006c79f6bde8b9c31c646ea0e"},"name":"closure_inline_std","profile":"rust-std","program":"cce3e8632d8c7b42f7961f9a6c0f734f50ea0eab68ab6e496f16558de67003ce","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5b5cb8b712efe50f580de93fe24776f3dfbaaa75efcefb60afb85aeb265f99d2","src/lib.rs":"938d07d0745e3d9be6f051487ba58a8ccc9d2c0006c79f6bde8b9c31c646ea0e"},"name":"closure_inline_std","profile":"rust-std","program":"cce3e8632d8c7b42f7961f9a6c0f734f50ea0eab68ab6e496f16558de67003ce","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-recursive/package.json b/compiler/rust/rust-std/closure-recursive/package.json index 97298275f..8292bc38c 100644 --- a/compiler/rust/rust-std/closure-recursive/package.json +++ b/compiler/rust/rust-std/closure-recursive/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"closure_recursive_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"kind":"var","name":2}},"bound":{"captures":[{"kind":"var","name":1}],"function":1,"kind":"closure"},"kind":"let","name":2,"type":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},"bound":{"captures":[],"function":2,"kind":"closure"},"kind":"let","name":1,"type":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"closure_recursive_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"kind":"var","name":2}},"bound":{"captures":[{"kind":"var","name":1}],"function":1,"kind":"closure"},"kind":"let","name":2,"type":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},"bound":{"captures":[],"function":2,"kind":"closure"},"kind":"let","name":1,"type":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-recursive/provenance.json b/compiler/rust/rust-std/closure-recursive/provenance.json index 9a477a5cc..1c02e0ca4 100644 --- a/compiler/rust/rust-std/closure-recursive/provenance.json +++ b/compiler/rust/rust-std/closure-recursive/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f6db8365b69e43ade216f5993b4f55d7ecfcf7131eab5cd8deaad84f6269a61","src/lib.rs":"b99a6cee6a59280031d6bf530fea6c7a4e3b6fae47f742eee2f0ed354810bf54"},"name":"closure_recursive_std","profile":"rust-std","program":"837e1e72b2e960d2360d8b2d6047eb52402faac0e1796676243bd01ebc1befaf","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f6db8365b69e43ade216f5993b4f55d7ecfcf7131eab5cd8deaad84f6269a61","src/lib.rs":"b99a6cee6a59280031d6bf530fea6c7a4e3b6fae47f742eee2f0ed354810bf54"},"name":"closure_recursive_std","profile":"rust-std","program":"837e1e72b2e960d2360d8b2d6047eb52402faac0e1796676243bd01ebc1befaf","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-uninhabited/package.json b/compiler/rust/rust-std/closure-uninhabited/package.json index 0a2c2ccd9..a43a04eed 100644 --- a/compiler/rust/rust-std/closure-uninhabited/package.json +++ b/compiler/rust/rust-std/closure-uninhabited/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"closure_uninhabited_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":2}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"closure_uninhabited_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":2}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}}},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closure-uninhabited/provenance.json b/compiler/rust/rust-std/closure-uninhabited/provenance.json index 3ca264fca..326ad0c7d 100644 --- a/compiler/rust/rust-std/closure-uninhabited/provenance.json +++ b/compiler/rust/rust-std/closure-uninhabited/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"04d6b324f4c65f5513123c9ef98cb4cab811b35341cf5c35fe56d03293429bc7","src/lib.rs":"544ddb0dbd7e521411c081ea1c60a713fff177cdb03367246f957b866eba6444"},"name":"closure_uninhabited_std","profile":"rust-std","program":"057be489c5323c3dc11411532fd63e39ec3436d200fc45dfd8e385bec6106b04","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"04d6b324f4c65f5513123c9ef98cb4cab811b35341cf5c35fe56d03293429bc7","src/lib.rs":"544ddb0dbd7e521411c081ea1c60a713fff177cdb03367246f957b866eba6444"},"name":"closure_uninhabited_std","profile":"rust-std","program":"057be489c5323c3dc11411532fd63e39ec3436d200fc45dfd8e385bec6106b04","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closures/package.json b/compiler/rust/rust-std/closures/package.json index 7c8a1230d..32e6f59f9 100644 --- a/compiler/rust/rust-std/closures/package.json +++ b/compiler/rust/rust-std/closures/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/closures/provenance.json b/compiler/rust/rust-std/closures/provenance.json index 6f81302af..30b6bdd6d 100644 --- a/compiler/rust/rust-std/closures/provenance.json +++ b/compiler/rust/rust-std/closures/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"dc94fa130dfb344cb9f25385def51572570da514423c2ca7c1f15af3d113478f","src/lib.rs":"42173a0ef40045059859a5f616c1f407fa4d0a67215d4dcede94d0c950d650d9"},"name":"closures_std","profile":"rust-std","program":"1853f6da889803b1a20a6b08710abf3c24a96ca453073ec176f5854649afcb98","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"dc94fa130dfb344cb9f25385def51572570da514423c2ca7c1f15af3d113478f","src/lib.rs":"42173a0ef40045059859a5f616c1f407fa4d0a67215d4dcede94d0c950d650d9"},"name":"closures_std","profile":"rust-std","program":"1853f6da889803b1a20a6b08710abf3c24a96ca453073ec176f5854649afcb98","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/convert/package.json b/compiler/rust/rust-std/convert/package.json index c322e54bf..b7972815b 100644 --- a/compiler/rust/rust-std/convert/package.json +++ b/compiler/rust/rust-std/convert/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"convert_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"fixed","width":"u8"}},{"kind":"option","value":{"kind":"fixed","width":"u16"}},{"kind":"option","value":{"kind":"fixed","width":"u32"}},{"kind":"option","value":{"kind":"fixed","width":"u64"}},{"kind":"option","value":{"kind":"fixed","width":"i8"}},{"kind":"option","value":{"kind":"fixed","width":"i16"}},{"kind":"option","value":{"kind":"fixed","width":"i32"}},{"kind":"option","value":{"kind":"fixed","width":"i64"}}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"65535"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-32768"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"convert_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"fixed","width":"u8"}},{"kind":"option","value":{"kind":"fixed","width":"u16"}},{"kind":"option","value":{"kind":"fixed","width":"u32"}},{"kind":"option","value":{"kind":"fixed","width":"u64"}},{"kind":"option","value":{"kind":"fixed","width":"i8"}},{"kind":"option","value":{"kind":"fixed","width":"i16"}},{"kind":"option","value":{"kind":"fixed","width":"i32"}},{"kind":"option","value":{"kind":"fixed","width":"i64"}}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"65535"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-32768"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/convert/provenance.json b/compiler/rust/rust-std/convert/provenance.json index 117ecc51b..9817c9abf 100644 --- a/compiler/rust/rust-std/convert/provenance.json +++ b/compiler/rust/rust-std/convert/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"186b3f1828951cb08082806c9210e4dbf844513fe1d48a27ca5d74f8d67f2b54","src/lib.rs":"970c4741fa0a2f13bd0b8d405aa9f405ebd84463f81ce1d1460956b03dd455c0"},"name":"convert_std","profile":"rust-std","program":"53f534696ea7212909ffcf637122ef370f71853fc0ce58655b91be97455279f5","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"186b3f1828951cb08082806c9210e4dbf844513fe1d48a27ca5d74f8d67f2b54","src/lib.rs":"970c4741fa0a2f13bd0b8d405aa9f405ebd84463f81ce1d1460956b03dd455c0"},"name":"convert_std","profile":"rust-std","program":"53f534696ea7212909ffcf637122ef370f71853fc0ce58655b91be97455279f5","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal-overflow-wide/package.json b/compiler/rust/rust-std/decimal-overflow-wide/package.json index 5e49a9403..cdabb4698 100644 --- a/compiler/rust/rust-std/decimal-overflow-wide/package.json +++ b/compiler/rust/rust-std/decimal-overflow-wide/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_overflow_wide_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"10000000000000000000000000000000000000000"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},"parameters":[],"result":{"kind":"option","value":{"kind":"int"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_overflow_wide_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"10000000000000000000000000000000000000000"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},"parameters":[],"result":{"kind":"option","value":{"kind":"int"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal-overflow-wide/provenance.json b/compiler/rust/rust-std/decimal-overflow-wide/provenance.json index 4153fb68c..3d1c3a10a 100644 --- a/compiler/rust/rust-std/decimal-overflow-wide/provenance.json +++ b/compiler/rust/rust-std/decimal-overflow-wide/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8f2688f2b9be7e8b4941212040e903215f55599c6b072a55166df7aee74ef0b1","src/lib.rs":"f190deab80ccf28489de8079d90a09ade862bbe08c849a0e73c7dd8f631f8b91"},"name":"decimal_overflow_wide_std","profile":"rust-std","program":"2eb56b9de0ed586a9904ebd46b52284abcf89305b744cf7d02248ca3ea38a437","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8f2688f2b9be7e8b4941212040e903215f55599c6b072a55166df7aee74ef0b1","src/lib.rs":"f190deab80ccf28489de8079d90a09ade862bbe08c849a0e73c7dd8f631f8b91"},"name":"decimal_overflow_wide_std","profile":"rust-std","program":"2eb56b9de0ed586a9904ebd46b52284abcf89305b744cf7d02248ca3ea38a437","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal-overflow/package.json b/compiler/rust/rust-std/decimal-overflow/package.json index 7692a2266..766a2455f 100644 --- a/compiler/rust/rust-std/decimal-overflow/package.json +++ b/compiler/rust/rust-std/decimal-overflow/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_overflow_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"9223372036854775808"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},"parameters":[],"result":{"kind":"option","value":{"kind":"int"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_overflow_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"9223372036854775808"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},"parameters":[],"result":{"kind":"option","value":{"kind":"int"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal-overflow/provenance.json b/compiler/rust/rust-std/decimal-overflow/provenance.json index d09a5afcf..c6c68c4d4 100644 --- a/compiler/rust/rust-std/decimal-overflow/provenance.json +++ b/compiler/rust/rust-std/decimal-overflow/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b5362b31d364c5322f81ea3a913999d029e11436d1dda27ae4a7f1be1a7bb254","src/lib.rs":"fd611ff2a78cb5260a0618dd736ab78730976b452ea91ad72419d978bf991e2f"},"name":"decimal_overflow_std","profile":"rust-std","program":"1c9f1ff8a2866ebe8ee40dcd094b558723ac3a80054cbd83e599ba63cbd7841c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b5362b31d364c5322f81ea3a913999d029e11436d1dda27ae4a7f1be1a7bb254","src/lib.rs":"fd611ff2a78cb5260a0618dd736ab78730976b452ea91ad72419d978bf991e2f"},"name":"decimal_overflow_std","profile":"rust-std","program":"1c9f1ff8a2866ebe8ee40dcd094b558723ac3a80054cbd83e599ba63cbd7841c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal/package.json b/compiler/rust/rust-std/decimal/package.json index 3843b3543..c382d1868 100644 --- a/compiler/rust/rust-std/decimal/package.json +++ b/compiler/rust/rust-std/decimal/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-42"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"123"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-0"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"007"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"+5"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-9223372036854775808"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"12a"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"255"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"256"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-1"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"decimal_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-42"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}}],"operation":{"kind":"format_decimal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"123"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-0"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"007"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"+5"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-9223372036854775808"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"12a"}}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"255"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"256"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-1"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0"}}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"int"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/decimal/provenance.json b/compiler/rust/rust-std/decimal/provenance.json index b6db351d2..2bc50eaca 100644 --- a/compiler/rust/rust-std/decimal/provenance.json +++ b/compiler/rust/rust-std/decimal/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4de336d24eccd5b8c7610e67d45f0f54333e2cbc4409e3bd6ea04275a068d3dc","src/lib.rs":"cfdc59f297dd78321a99d53d799aeea3577c9c573171169989ba0ce921a5e8cc"},"name":"decimal_std","profile":"rust-std","program":"917f310d200f9f4fa5ebf83c791b56d8e08333293edf4fc50fd597570ae58d4d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4de336d24eccd5b8c7610e67d45f0f54333e2cbc4409e3bd6ea04275a068d3dc","src/lib.rs":"cfdc59f297dd78321a99d53d799aeea3577c9c573171169989ba0ce921a5e8cc"},"name":"decimal_std","profile":"rust-std","program":"917f310d200f9f4fa5ebf83c791b56d8e08333293edf4fc50fd597570ae58d4d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/equality/package.json b/compiler/rust/rust-std/equality/package.json index bec29352c..638d71b29 100644 --- a/compiler/rust/rust-std/equality/package.json +++ b/compiler/rust/rust-std/equality/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"equality_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"compare"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"1"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"equality_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"compare"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"lt"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"1"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/equality/provenance.json b/compiler/rust/rust-std/equality/provenance.json index 7dd83c0b3..acceaa43d 100644 --- a/compiler/rust/rust-std/equality/provenance.json +++ b/compiler/rust/rust-std/equality/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"01ae42b51273b4ca067a4e5295206260cbcbbab4b765b04045954060004d3ce1","src/lib.rs":"649f7a4c1d4377c9a8f22cd463f21defdef0cb3330f2cc0bc943ea8a838c98ff"},"name":"equality_std","profile":"rust-std","program":"60cbf0f5a5314bb087d9eb23ac978b692465e0b4defea241a2f8917c776ee53a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"01ae42b51273b4ca067a4e5295206260cbcbbab4b765b04045954060004d3ce1","src/lib.rs":"649f7a4c1d4377c9a8f22cd463f21defdef0cb3330f2cc0bc943ea8a838c98ff"},"name":"equality_std","profile":"rust-std","program":"60cbf0f5a5314bb087d9eb23ac978b692465e0b4defea241a2f8917c776ee53a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fallible-condition-value/package.json b/compiler/rust/rust-std/fallible-condition-value/package.json index 7445bc3b4..f2fbfa853 100644 --- a/compiler/rust/rust-std/fallible-condition-value/package.json +++ b/compiler/rust/rust-std/fallible-condition-value/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"fallible_condition_value_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"fallible_condition_value_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fallible-condition-value/provenance.json b/compiler/rust/rust-std/fallible-condition-value/provenance.json index 5aebb92c5..ddecbd397 100644 --- a/compiler/rust/rust-std/fallible-condition-value/provenance.json +++ b/compiler/rust/rust-std/fallible-condition-value/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ff8caa18077ba0b84554e6608e87ada6df04c923d5424f5a09bbd7c041222b74","src/lib.rs":"6e99d97fbf4346956d10e02e2702e1bc3dd048bf868cd2b1ad02ec9699b76a1f"},"name":"fallible_condition_value_std","profile":"rust-std","program":"1e4bbfc9aa1667d930aa5d3c7df5105e11161bde3842639d8fd684b9e7c9ab80","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ff8caa18077ba0b84554e6608e87ada6df04c923d5424f5a09bbd7c041222b74","src/lib.rs":"6e99d97fbf4346956d10e02e2702e1bc3dd048bf868cd2b1ad02ec9699b76a1f"},"name":"fallible_condition_value_std","profile":"rust-std","program":"1e4bbfc9aa1667d930aa5d3c7df5105e11161bde3842639d8fd684b9e7c9ab80","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-bits-signed/package.json b/compiler/rust/rust-std/fixed-bits-signed/package.json index 7f1735e26..d8e31a78b 100644 --- a/compiler/rust/rust-std/fixed-bits-signed/package.json +++ b/compiler/rust/rust-std/fixed-bits-signed/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_bits_signed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"0"}}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"85"}}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"64"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_bits_signed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"0"}}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"85"}}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"64"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-bits-signed/provenance.json b/compiler/rust/rust-std/fixed-bits-signed/provenance.json index 740b5378f..964c2715a 100644 --- a/compiler/rust/rust-std/fixed-bits-signed/provenance.json +++ b/compiler/rust/rust-std/fixed-bits-signed/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f871d81d9fc4899c784298ce0e48b0c3c85a38f28d1aa3a1215f3555e76bbbde","src/lib.rs":"b27b0bd2257f07014bfcad7a71e2db95c4859ac11d6ccbafed7c7d2430ce50c8"},"name":"fixed_bits_signed_std","profile":"rust-std","program":"6c9d502f069507ff072ae6bfd7948657e1eb89d4f56767270c22b4c0d94d1bcb","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f871d81d9fc4899c784298ce0e48b0c3c85a38f28d1aa3a1215f3555e76bbbde","src/lib.rs":"b27b0bd2257f07014bfcad7a71e2db95c4859ac11d6ccbafed7c7d2430ce50c8"},"name":"fixed_bits_signed_std","profile":"rust-std","program":"6c9d502f069507ff072ae6bfd7948657e1eb89d4f56767270c22b4c0d94d1bcb","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-bits-unsigned/package.json b/compiler/rust/rust-std/fixed-bits-unsigned/package.json index 44056bd59..92bc959ee 100644 --- a/compiler/rust/rust-std/fixed-bits-unsigned/package.json +++ b/compiler/rust/rust-std/fixed-bits-unsigned/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_bits_unsigned_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"240"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"60"}}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"240"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"12"}}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"15"}}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"0"}}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"129"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"9"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"fixed","width":"u8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"fixed","width":"u8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_bits_unsigned_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"240"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"60"}}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"240"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"12"}}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"15"}}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"0"}}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"u8"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"129"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"1"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"7"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"9"}}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"fixed","width":"u8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"fixed","width":"u8"},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-bits-unsigned/provenance.json b/compiler/rust/rust-std/fixed-bits-unsigned/provenance.json index 9b45821a6..2f757811f 100644 --- a/compiler/rust/rust-std/fixed-bits-unsigned/provenance.json +++ b/compiler/rust/rust-std/fixed-bits-unsigned/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e320b5bea08c3075f1547cef263c16b05ee771fd553e78e2016874a72bfef600","src/lib.rs":"b11239851d649dfb4cfac5996223562daef5bee04f5fd64a0a5fa8c07413949f"},"name":"fixed_bits_unsigned_std","profile":"rust-std","program":"96eb8f161d9bb4e0f9f006be3e5df5125525a2888aec343e03b99de23bb5d9eb","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e320b5bea08c3075f1547cef263c16b05ee771fd553e78e2016874a72bfef600","src/lib.rs":"b11239851d649dfb4cfac5996223562daef5bee04f5fd64a0a5fa8c07413949f"},"name":"fixed_bits_unsigned_std","profile":"rust-std","program":"96eb8f161d9bb4e0f9f006be3e5df5125525a2888aec343e03b99de23bb5d9eb","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-narrow/package.json b/compiler/rust/rust-std/fixed-checked-narrow/package.json index e45ca0980..464c2228b 100644 --- a/compiler/rust/rust-std/fixed-checked-narrow/package.json +++ b/compiler/rust/rust-std/fixed-checked-narrow/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_narrow_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"15"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"17"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65000"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"535"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32768"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32767"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"65536"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"65536"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"9"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483648"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483647"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_narrow_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"15"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"17"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65000"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"535"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32768"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32767"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"65536"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"65536"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"9"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483648"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483647"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"kind":"list"}}}}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-narrow/provenance.json b/compiler/rust/rust-std/fixed-checked-narrow/provenance.json index 46e9a25d7..5e28955e4 100644 --- a/compiler/rust/rust-std/fixed-checked-narrow/provenance.json +++ b/compiler/rust/rust-std/fixed-checked-narrow/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e95afae963b20737123226cf65e4ae7b78f41c3032df05d51a93b326916ae0c1","src/lib.rs":"11d91c22a05213e8eccdf406823fe9b74948a90be211e5922e4ff6e717ae0288"},"name":"fixed_checked_narrow_std","profile":"rust-std","program":"e1ee29f08689361924b2e4fab8b538d626ee0a2af4597cb924b1a1d45204cb0d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e95afae963b20737123226cf65e4ae7b78f41c3032df05d51a93b326916ae0c1","src/lib.rs":"11d91c22a05213e8eccdf406823fe9b74948a90be211e5922e4ff6e717ae0288"},"name":"fixed_checked_narrow_std","profile":"rust-std","program":"e1ee29f08689361924b2e4fab8b538d626ee0a2af4597cb924b1a1d45204cb0d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-signed/package.json b/compiler/rust/rust-std/fixed-checked-signed/package.json index 4fa0eb49a..53f413a42 100644 --- a/compiler/rust/rust-std/fixed-checked-signed/package.json +++ b/compiler/rust/rust-std/fixed-checked-signed/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_signed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"127"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"100"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"27"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-64"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"2"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"16"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"16"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"5"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"7"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"0"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-7"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"2"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_signed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"127"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"100"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"27"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-64"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"2"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"16"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"16"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"5"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"7"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"0"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-7"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"2"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-signed/provenance.json b/compiler/rust/rust-std/fixed-checked-signed/provenance.json index a4744f309..10bd55cb6 100644 --- a/compiler/rust/rust-std/fixed-checked-signed/provenance.json +++ b/compiler/rust/rust-std/fixed-checked-signed/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4964e71a361318314437bb557b92bbfb39faac25f1e67555316f7f10e993811b","src/lib.rs":"d57c8b8ca18aa96b1cf4b88d8895939a4e3f1487e5eecf66bf29787452801c32"},"name":"fixed_checked_signed_std","profile":"rust-std","program":"9f5fded1de374e8c05f3da2df5057e3c1f4648b06ed06dae7f3940179f3bea93","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4964e71a361318314437bb557b92bbfb39faac25f1e67555316f7f10e993811b","src/lib.rs":"d57c8b8ca18aa96b1cf4b88d8895939a4e3f1487e5eecf66bf29787452801c32"},"name":"fixed_checked_signed_std","profile":"rust-std","program":"9f5fded1de374e8c05f3da2df5057e3c1f4648b06ed06dae7f3940179f3bea93","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-wide/package.json b/compiler/rust/rust-std/fixed-checked-wide/package.json index 987e47a27..cafd66e44 100644 --- a/compiler/rust/rust-std/fixed-checked-wide/package.json +++ b/compiler/rust/rust-std/fixed-checked-wide/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_wide_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-1"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-3037000499"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"3037000499"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"7"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967296"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967296"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967295"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967297"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"16"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"fixed_checked_wide_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-1"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-3037000499"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"3037000499"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-1"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"7"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967296"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967296"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967295"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"4294967297"}}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"16"}}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"kind":"list"},"right":{"element":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-checked-wide/provenance.json b/compiler/rust/rust-std/fixed-checked-wide/provenance.json index 2e0f345b4..cc2469fb0 100644 --- a/compiler/rust/rust-std/fixed-checked-wide/provenance.json +++ b/compiler/rust/rust-std/fixed-checked-wide/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b12ee21dde2e598d2f7df74efab7b21048a8aeb5d06d664f2cf68179f108f9e4","src/lib.rs":"c5341c261169122a9d2e7dee4534ea00e07636647a7fa986a3b84d7472cad1d5"},"name":"fixed_checked_wide_std","profile":"rust-std","program":"a7dd87527d7b8a8f41e5ceb6fe7da703c570fd388f042f5977421e66fb77f2f8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b12ee21dde2e598d2f7df74efab7b21048a8aeb5d06d664f2cf68179f108f9e4","src/lib.rs":"c5341c261169122a9d2e7dee4534ea00e07636647a7fa986a3b84d7472cad1d5"},"name":"fixed_checked_wide_std","profile":"rust-std","program":"a7dd87527d7b8a8f41e5ceb6fe7da703c570fd388f042f5977421e66fb77f2f8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i16/package.json b/compiler/rust/rust-std/fixed-decimal-i16/package.json index 626e8f052..781a6fe81 100644 --- a/compiler/rust/rust-std/fixed-decimal-i16/package.json +++ b/compiler/rust/rust-std/fixed-decimal-i16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i16"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i16"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i16"}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i16"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i16"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i16"}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i16/provenance.json b/compiler/rust/rust-std/fixed-decimal-i16/provenance.json index 42b159cd3..424ed1797 100644 --- a/compiler/rust/rust-std/fixed-decimal-i16/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-i16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a59d41814aa524370e84433f7d33372cab7324ce572f8f096477f475432a8d33","src/lib.rs":"6ea4209d9311ec748dfb89582c9ca3a1ce94bb31c850a7408332d64cc8e3d19f"},"name":"fixed_decimal_i16_std","profile":"rust-std","program":"89b37d79a3be04d78ab73a737c875066a8b6015505ff7d08345f978955598638","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a59d41814aa524370e84433f7d33372cab7324ce572f8f096477f475432a8d33","src/lib.rs":"6ea4209d9311ec748dfb89582c9ca3a1ce94bb31c850a7408332d64cc8e3d19f"},"name":"fixed_decimal_i16_std","profile":"rust-std","program":"89b37d79a3be04d78ab73a737c875066a8b6015505ff7d08345f978955598638","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i32/package.json b/compiler/rust/rust-std/fixed-decimal-i32/package.json index 62964c201..1fb8c02a2 100644 --- a/compiler/rust/rust-std/fixed-decimal-i32/package.json +++ b/compiler/rust/rust-std/fixed-decimal-i32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i32"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i32"}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i32"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i32"}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i32/provenance.json b/compiler/rust/rust-std/fixed-decimal-i32/provenance.json index 135ca1fb4..2580b2ba9 100644 --- a/compiler/rust/rust-std/fixed-decimal-i32/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-i32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6588c07da677119bd26c26a1eba39e8f490e5e0834e2744e4157b9e818a5ea04","src/lib.rs":"522dd2bf570a358a252a34f712a1bca3eac9e735ea192160d646963cf261cde3"},"name":"fixed_decimal_i32_std","profile":"rust-std","program":"c82e9607bcb2b657ef8a24e7eee7b6eb956668a53f03f6ee5b40f5789e511dfd","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6588c07da677119bd26c26a1eba39e8f490e5e0834e2744e4157b9e818a5ea04","src/lib.rs":"522dd2bf570a358a252a34f712a1bca3eac9e735ea192160d646963cf261cde3"},"name":"fixed_decimal_i32_std","profile":"rust-std","program":"c82e9607bcb2b657ef8a24e7eee7b6eb956668a53f03f6ee5b40f5789e511dfd","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i64/package.json b/compiler/rust/rust-std/fixed-decimal-i64/package.json index 9f2b00b14..639039bea 100644 --- a/compiler/rust/rust-std/fixed-decimal-i64/package.json +++ b/compiler/rust/rust-std/fixed-decimal-i64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i64"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i64"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i64/provenance.json b/compiler/rust/rust-std/fixed-decimal-i64/provenance.json index 9f111fc97..86ea556b0 100644 --- a/compiler/rust/rust-std/fixed-decimal-i64/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-i64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6249ebde29c7bf618a1221eacd8f2dcbcf2f42eaf2a9688a3ffa9fec5288c829","src/lib.rs":"62401bb3dac69e30842c0cebd580ff360d7cc3dc09c81c99fe128817a5a7f039"},"name":"fixed_decimal_i64_std","profile":"rust-std","program":"785d836fa54d435e12beb5276622ea28adae2cee3ba08424c06eea5aab25ba29","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6249ebde29c7bf618a1221eacd8f2dcbcf2f42eaf2a9688a3ffa9fec5288c829","src/lib.rs":"62401bb3dac69e30842c0cebd580ff360d7cc3dc09c81c99fe128817a5a7f039"},"name":"fixed_decimal_i64_std","profile":"rust-std","program":"785d836fa54d435e12beb5276622ea28adae2cee3ba08424c06eea5aab25ba29","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i8/package.json b/compiler/rust/rust-std/fixed-decimal-i8/package.json index e68ddfe03..2a7044b2c 100644 --- a/compiler/rust/rust-std/fixed-decimal-i8/package.json +++ b/compiler/rust/rust-std/fixed-decimal-i8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i8"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_i8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"i8"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-i8/provenance.json b/compiler/rust/rust-std/fixed-decimal-i8/provenance.json index 666a5a38b..64c0e7021 100644 --- a/compiler/rust/rust-std/fixed-decimal-i8/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-i8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4a405fe7ecb7b3b184653f976db65e74d29ec3c4beae0232fab83fe1e664f1ea","src/lib.rs":"48a11400a02155faf4c2145ed34925458d901ceaa7eeb182af46817ebeac723b"},"name":"fixed_decimal_i8_std","profile":"rust-std","program":"14a60e07970669a503125f5b991dfb159f254255caa1497e52d9abb25c61de84","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4a405fe7ecb7b3b184653f976db65e74d29ec3c4beae0232fab83fe1e664f1ea","src/lib.rs":"48a11400a02155faf4c2145ed34925458d901ceaa7eeb182af46817ebeac723b"},"name":"fixed_decimal_i8_std","profile":"rust-std","program":"14a60e07970669a503125f5b991dfb159f254255caa1497e52d9abb25c61de84","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u16/package.json b/compiler/rust/rust-std/fixed-decimal-u16/package.json index da75066e2..483a800c8 100644 --- a/compiler/rust/rust-std/fixed-decimal-u16/package.json +++ b/compiler/rust/rust-std/fixed-decimal-u16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u16"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u16"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u16"}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u16"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u16"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u16"}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u16/provenance.json b/compiler/rust/rust-std/fixed-decimal-u16/provenance.json index 91bb61dd4..942196bfb 100644 --- a/compiler/rust/rust-std/fixed-decimal-u16/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-u16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"21e8c7595089e11ff728aac7ebb0bb09602e02b6513fb4e90dc6346e3e4af84f","src/lib.rs":"7b4595b5e02b9e307668b4ec4d3e139d76ccc5550767f09aa00c714dd7432cd6"},"name":"fixed_decimal_u16_std","profile":"rust-std","program":"f1a32f6ce00adfb60b0c9f4c5069d16f9fc4887d5cd07876af1c9918f998d21a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"21e8c7595089e11ff728aac7ebb0bb09602e02b6513fb4e90dc6346e3e4af84f","src/lib.rs":"7b4595b5e02b9e307668b4ec4d3e139d76ccc5550767f09aa00c714dd7432cd6"},"name":"fixed_decimal_u16_std","profile":"rust-std","program":"f1a32f6ce00adfb60b0c9f4c5069d16f9fc4887d5cd07876af1c9918f998d21a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u32/package.json b/compiler/rust/rust-std/fixed-decimal-u32/package.json index 9ac376685..a7190afd0 100644 --- a/compiler/rust/rust-std/fixed-decimal-u32/package.json +++ b/compiler/rust/rust-std/fixed-decimal-u32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u32/provenance.json b/compiler/rust/rust-std/fixed-decimal-u32/provenance.json index 25a981ea2..bc7014bb6 100644 --- a/compiler/rust/rust-std/fixed-decimal-u32/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-u32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"adc66c6240acbd13cd6d2f31d3a5187f2a97773e864635bb1fb41f73e73bd75f","src/lib.rs":"fa4904b35271fd7bc08c7a6a1a8efdcc59359821fe1cc8222488bd8aa8664d47"},"name":"fixed_decimal_u32_std","profile":"rust-std","program":"bb8e626dc5598c29492979bc05547188e293b3a89987a866d6f7b5cbde14fa30","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"adc66c6240acbd13cd6d2f31d3a5187f2a97773e864635bb1fb41f73e73bd75f","src/lib.rs":"fa4904b35271fd7bc08c7a6a1a8efdcc59359821fe1cc8222488bd8aa8664d47"},"name":"fixed_decimal_u32_std","profile":"rust-std","program":"bb8e626dc5598c29492979bc05547188e293b3a89987a866d6f7b5cbde14fa30","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u64/package.json b/compiler/rust/rust-std/fixed-decimal-u64/package.json index 475a0ca1a..a3900bbe8 100644 --- a/compiler/rust/rust-std/fixed-decimal-u64/package.json +++ b/compiler/rust/rust-std/fixed-decimal-u64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u64"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u64"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u64/provenance.json b/compiler/rust/rust-std/fixed-decimal-u64/provenance.json index 283275b60..d64f54408 100644 --- a/compiler/rust/rust-std/fixed-decimal-u64/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-u64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f32638b5b0e4c7880f7e3825207ed5be713ff9ee28078dfecdc0733610a25fb7","src/lib.rs":"037401fb04368ce8cbfab87738220f41338f1297ae230272af61a1955af1d4fc"},"name":"fixed_decimal_u64_std","profile":"rust-std","program":"5ae83fff2b2b4e34046e3dc348d93ee8db42c5bfe95f4cdce6f67ef2808a6d3c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f32638b5b0e4c7880f7e3825207ed5be713ff9ee28078dfecdc0733610a25fb7","src/lib.rs":"037401fb04368ce8cbfab87738220f41338f1297ae230272af61a1955af1d4fc"},"name":"fixed_decimal_u64_std","profile":"rust-std","program":"5ae83fff2b2b4e34046e3dc348d93ee8db42c5bfe95f4cdce6f67ef2808a6d3c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u8/package.json b/compiler/rust/rust-std/fixed-decimal-u8/package.json index 52bc9ca62..6fb645535 100644 --- a/compiler/rust/rust-std/fixed-decimal-u8/package.json +++ b/compiler/rust/rust-std/fixed-decimal-u8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u8"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u8"}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_decimal_u8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u8"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u8"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"option","value":{"kind":"fixed","width":"u8"}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-decimal-u8/provenance.json b/compiler/rust/rust-std/fixed-decimal-u8/provenance.json index b2015f890..45337cd38 100644 --- a/compiler/rust/rust-std/fixed-decimal-u8/provenance.json +++ b/compiler/rust/rust-std/fixed-decimal-u8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5cf821591b25b595bfb765eef85ae77e20e0da9fb292ef3ceff8cc0cf3b0c530","src/lib.rs":"0b01c22de8dcd4d1f7d02e13a14f753b89af89f749450dc864c75dac2c330f96"},"name":"fixed_decimal_u8_std","profile":"rust-std","program":"e6b650c8e38c51cacdff8d110e4d9583226d457160f3dd2ba10bb725f9a2d751","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5cf821591b25b595bfb765eef85ae77e20e0da9fb292ef3ceff8cc0cf3b0c530","src/lib.rs":"0b01c22de8dcd4d1f7d02e13a14f753b89af89f749450dc864c75dac2c330f96"},"name":"fixed_decimal_u8_std","profile":"rust-std","program":"e6b650c8e38c51cacdff8d110e4d9583226d457160f3dd2ba10bb725f9a2d751","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i16/package.json b/compiler/rust/rust-std/fixed-width-i16/package.json index 6b5b0d029..74002e02a 100644 --- a/compiler/rust/rust-std/fixed-width-i16/package.json +++ b/compiler/rust/rust-std/fixed-width-i16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i16/provenance.json b/compiler/rust/rust-std/fixed-width-i16/provenance.json index 34f36d0ce..2db327516 100644 --- a/compiler/rust/rust-std/fixed-width-i16/provenance.json +++ b/compiler/rust/rust-std/fixed-width-i16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ac3e941463beedf8f36065be8c6bc2dab16ae4493e1b932b25021d45792f9bb5","src/lib.rs":"0fe14e563b17aa0e7023ec82925f8461eb64c0d8b7e8cd81b6d78bbb01d375b2"},"name":"fixed_width_i16_std","profile":"rust-std","program":"23f1a6e3b665ccabf568dce2bcfd6ca2247170568ae24f097dc9f260f0d2369e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ac3e941463beedf8f36065be8c6bc2dab16ae4493e1b932b25021d45792f9bb5","src/lib.rs":"0fe14e563b17aa0e7023ec82925f8461eb64c0d8b7e8cd81b6d78bbb01d375b2"},"name":"fixed_width_i16_std","profile":"rust-std","program":"23f1a6e3b665ccabf568dce2bcfd6ca2247170568ae24f097dc9f260f0d2369e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i32/package.json b/compiler/rust/rust-std/fixed-width-i32/package.json index 12c30c796..33f3a9505 100644 --- a/compiler/rust/rust-std/fixed-width-i32/package.json +++ b/compiler/rust/rust-std/fixed-width-i32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i32/provenance.json b/compiler/rust/rust-std/fixed-width-i32/provenance.json index 8a963bd70..808c22e08 100644 --- a/compiler/rust/rust-std/fixed-width-i32/provenance.json +++ b/compiler/rust/rust-std/fixed-width-i32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6582666bf5c49fdb65bcb1ac6fd4bc1231bad9b5048bb365a05bd3de00fb3c07","src/lib.rs":"801b1676ee623f1037e12fa29dcbdbe7cf2a07e6ea19d20cdf48885bd63f51b7"},"name":"fixed_width_i32_std","profile":"rust-std","program":"a55c0f3839fd471d83e04fe51ad076da864407a9027bc8225331cb1e562880ee","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6582666bf5c49fdb65bcb1ac6fd4bc1231bad9b5048bb365a05bd3de00fb3c07","src/lib.rs":"801b1676ee623f1037e12fa29dcbdbe7cf2a07e6ea19d20cdf48885bd63f51b7"},"name":"fixed_width_i32_std","profile":"rust-std","program":"a55c0f3839fd471d83e04fe51ad076da864407a9027bc8225331cb1e562880ee","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i64/package.json b/compiler/rust/rust-std/fixed-width-i64/package.json index 53fe950b0..db99abf1d 100644 --- a/compiler/rust/rust-std/fixed-width-i64/package.json +++ b/compiler/rust/rust-std/fixed-width-i64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i64/provenance.json b/compiler/rust/rust-std/fixed-width-i64/provenance.json index 2860b7346..a7ff88a8e 100644 --- a/compiler/rust/rust-std/fixed-width-i64/provenance.json +++ b/compiler/rust/rust-std/fixed-width-i64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cde911b169deaabeb45fab6fdda2b9f2eae776b91ee419c40331bfd5812c48af","src/lib.rs":"6a9ed2eead6111996e8e87e37bf6c127e4f488885243f5b4d71961ce3d252efa"},"name":"fixed_width_i64_std","profile":"rust-std","program":"bf6c9acc0c25eb22d8c1deb59574ad70d65f06123c556ed17e1b7c5bbc5aa902","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cde911b169deaabeb45fab6fdda2b9f2eae776b91ee419c40331bfd5812c48af","src/lib.rs":"6a9ed2eead6111996e8e87e37bf6c127e4f488885243f5b4d71961ce3d252efa"},"name":"fixed_width_i64_std","profile":"rust-std","program":"bf6c9acc0c25eb22d8c1deb59574ad70d65f06123c556ed17e1b7c5bbc5aa902","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i8/package.json b/compiler/rust/rust-std/fixed-width-i8/package.json index 5ca5cc714..6e0cf8cfd 100644 --- a/compiler/rust/rust-std/fixed-width-i8/package.json +++ b/compiler/rust/rust-std/fixed-width-i8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_i8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"checked_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"i8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-i8/provenance.json b/compiler/rust/rust-std/fixed-width-i8/provenance.json index aba80e011..cf3ff1ff3 100644 --- a/compiler/rust/rust-std/fixed-width-i8/provenance.json +++ b/compiler/rust/rust-std/fixed-width-i8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0d77a1e1b8ac41d3b057dfd7e202ecc9ce54669755cbdb58c61e4a9e92e37eeb","src/lib.rs":"e4b66e46b712ccf3e6c6153a6ed2978ba817eda5b0f9e561fade6d5c4d5cadbb"},"name":"fixed_width_i8_std","profile":"rust-std","program":"d57d16e24c0ae93fc46223897266514db7bf77781397039e12b9f8781e3b6631","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0d77a1e1b8ac41d3b057dfd7e202ecc9ce54669755cbdb58c61e4a9e92e37eeb","src/lib.rs":"e4b66e46b712ccf3e6c6153a6ed2978ba817eda5b0f9e561fade6d5c4d5cadbb"},"name":"fixed_width_i8_std","profile":"rust-std","program":"d57d16e24c0ae93fc46223897266514db7bf77781397039e12b9f8781e3b6631","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u16/package.json b/compiler/rust/rust-std/fixed-width-u16/package.json index 738b1d24c..9fd05561c 100644 --- a/compiler/rust/rust-std/fixed-width-u16/package.json +++ b/compiler/rust/rust-std/fixed-width-u16/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u16_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"16"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u16"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u16/provenance.json b/compiler/rust/rust-std/fixed-width-u16/provenance.json index 23978746d..fba48def6 100644 --- a/compiler/rust/rust-std/fixed-width-u16/provenance.json +++ b/compiler/rust/rust-std/fixed-width-u16/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f5d626f7aa7566339d1b44ae264c3fb6fa6c4aa24d381558907e415a6176e2e","src/lib.rs":"b16bf3ba972a1fa7386094b346da2d58c0b8a70a3dda08668da9332b063df634"},"name":"fixed_width_u16_std","profile":"rust-std","program":"9b805d1f67c7b7fa48388bf6b3921d64f311b660e5894d4c4ad299390f0ef380","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f5d626f7aa7566339d1b44ae264c3fb6fa6c4aa24d381558907e415a6176e2e","src/lib.rs":"b16bf3ba972a1fa7386094b346da2d58c0b8a70a3dda08668da9332b063df634"},"name":"fixed_width_u16_std","profile":"rust-std","program":"9b805d1f67c7b7fa48388bf6b3921d64f311b660e5894d4c4ad299390f0ef380","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u32/package.json b/compiler/rust/rust-std/fixed-width-u32/package.json index 4d72f0783..00f29e240 100644 --- a/compiler/rust/rust-std/fixed-width-u32/package.json +++ b/compiler/rust/rust-std/fixed-width-u32/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u32_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"32"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u32"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u32"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u32/provenance.json b/compiler/rust/rust-std/fixed-width-u32/provenance.json index f833bdee2..c2032ff3e 100644 --- a/compiler/rust/rust-std/fixed-width-u32/provenance.json +++ b/compiler/rust/rust-std/fixed-width-u32/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2a6cff29ea67e59a4eedd7ae9b392f9b5a161aa68a1063c3e41170125f48d60e","src/lib.rs":"1adbe48dbd2f66a6210fd75661c391a42326fadc9a9eff950750ad9d6c8da9bb"},"name":"fixed_width_u32_std","profile":"rust-std","program":"b0d32e1ba47aad96742baed7ac5cc12f337d84e7d478c3d00ed0992be2861fe1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2a6cff29ea67e59a4eedd7ae9b392f9b5a161aa68a1063c3e41170125f48d60e","src/lib.rs":"1adbe48dbd2f66a6210fd75661c391a42326fadc9a9eff950750ad9d6c8da9bb"},"name":"fixed_width_u32_std","profile":"rust-std","program":"b0d32e1ba47aad96742baed7ac5cc12f337d84e7d478c3d00ed0992be2861fe1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u64/package.json b/compiler/rust/rust-std/fixed-width-u64/package.json index a9926b4c1..527a04b43 100644 --- a/compiler/rust/rust-std/fixed-width-u64/package.json +++ b/compiler/rust/rust-std/fixed-width-u64/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u64_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"64"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u64"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u64"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u64/provenance.json b/compiler/rust/rust-std/fixed-width-u64/provenance.json index fee34e966..7ddaa7e55 100644 --- a/compiler/rust/rust-std/fixed-width-u64/provenance.json +++ b/compiler/rust/rust-std/fixed-width-u64/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ec73f29a9126ee2d49de7fc1ad07cd8266830795de2e25887e20b3c51bb0b6c0","src/lib.rs":"09e06b1818312060acbb808fc9cc7716b6851a6ea0b0018872cb92a8665e2354"},"name":"fixed_width_u64_std","profile":"rust-std","program":"d173c6c0813a7ca7f471cf3a55f2a25c4771bbeea58ca9cd42e5ee35e352fc43","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ec73f29a9126ee2d49de7fc1ad07cd8266830795de2e25887e20b3c51bb0b6c0","src/lib.rs":"09e06b1818312060acbb808fc9cc7716b6851a6ea0b0018872cb92a8665e2354"},"name":"fixed_width_u64_std","profile":"rust-std","program":"d173c6c0813a7ca7f471cf3a55f2a25c4771bbeea58ca9cd42e5ee35e352fc43","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u8-passing/package.json b/compiler/rust/rust-std/fixed-width-u8-passing/package.json index 65508bee7..b51167c93 100644 --- a/compiler/rust/rust-std/fixed-width-u8-passing/package.json +++ b/compiler/rust/rust-std/fixed-width-u8-passing/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy","borrow","own"]}],"name":"fixed_width_u8_passing_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["copy","borrow","own"]}],"name":"fixed_width_u8_passing_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u8-passing/provenance.json b/compiler/rust/rust-std/fixed-width-u8-passing/provenance.json index 6d9acfa80..a02155366 100644 --- a/compiler/rust/rust-std/fixed-width-u8-passing/provenance.json +++ b/compiler/rust/rust-std/fixed-width-u8-passing/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"548ed7c45bd87abc6ff3a1939949401dbb6e6e30ac8975aa0f4b1778321f9855","src/lib.rs":"0370e79ec900b45a87a8d0e849cbb62900b547c3e9473a35d10cbf2a8bdad077"},"name":"fixed_width_u8_passing_std","profile":"rust-std","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"548ed7c45bd87abc6ff3a1939949401dbb6e6e30ac8975aa0f4b1778321f9855","src/lib.rs":"0370e79ec900b45a87a8d0e849cbb62900b547c3e9473a35d10cbf2a8bdad077"},"name":"fixed_width_u8_passing_std","profile":"rust-std","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u8/package.json b/compiler/rust/rust-std/fixed-width-u8/package.json index 1585087ac..ed9305fda 100644 --- a/compiler/rust/rust-std/fixed-width-u8/package.json +++ b/compiler/rust/rust-std/fixed-width-u8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_width_u8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_right"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"8"}}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"300"}}],"operation":{"kind":"convert","target":"u8"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u8"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"ordering"}}}}}}}}}}}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/fixed-width-u8/provenance.json b/compiler/rust/rust-std/fixed-width-u8/provenance.json index 62b705405..b57a1d508 100644 --- a/compiler/rust/rust-std/fixed-width-u8/provenance.json +++ b/compiler/rust/rust-std/fixed-width-u8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"18452ebfe5322a5e89f00aff96f6358ea98f50af4e8d59f35f549aa2e332d92f","src/lib.rs":"f2ed99f614b9d9c0457bb15fc00a45e7ad8b49446b461d5ec33eac11646947e1"},"name":"fixed_width_u8_std","profile":"rust-std","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"18452ebfe5322a5e89f00aff96f6358ea98f50af4e8d59f35f549aa2e332d92f","src/lib.rs":"f2ed99f614b9d9c0457bb15fc00a45e7ad8b49446b461d5ec33eac11646947e1"},"name":"fixed_width_u8_std","profile":"rust-std","program":"10a50859bd6fdf829c844b5c4758a464f5524865ef0b64f63cf0e9bb838c1d8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/function-shapes/package.json b/compiler/rust/rust-std/function-shapes/package.json index 987402d7c..924ff07ba 100644 --- a/compiler/rust/rust-std/function-shapes/package.json +++ b/compiler/rust/rust-std/function-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"function_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"3"}}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"4"}}}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"value","type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"5"}}}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}}]},{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"6"}}}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":false}}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"value","type":{"index":0,"kind":"adt"},"value":{"constructor":0,"fields":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"adt"}}]},{"function":9,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"1"}}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"types":[]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bool"}]},{"body":{"index":0,"kind":"field","value":{"arms":[{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"function_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"3"}}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"4"}}}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"value","type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"5"}}}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}}]},{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"6"}}}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":false}}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"value","type":{"index":0,"kind":"adt"},"value":{"constructor":0,"fields":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"adt"}}]},{"function":9,"kind":"call","operands":[{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"some","value":{"kind":"nat","value":"1"}}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}}},"parameters":[],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"types":[]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"condition":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"200"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bool"}]},{"body":{"index":0,"kind":"field","value":{"arms":[{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/function-shapes/provenance.json b/compiler/rust/rust-std/function-shapes/provenance.json index c9134bf41..beedd1f4a 100644 --- a/compiler/rust/rust-std/function-shapes/provenance.json +++ b/compiler/rust/rust-std/function-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3720c9f130285e3c390b2b0046c6a9a7796f49ac243f1badb2c5b06d088fc912","src/lib.rs":"6635977a6aefcea9911c98821ae4f0c89e4b2ce949057eec28d55891bbb6b9b6"},"name":"function_shapes_std","profile":"rust-std","program":"5156d5b2edb83f9b58b89720da3005d24bde4f212a0a5f4d25175cc4ba0628e9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3720c9f130285e3c390b2b0046c6a9a7796f49ac243f1badb2c5b06d088fc912","src/lib.rs":"6635977a6aefcea9911c98821ae4f0c89e4b2ce949057eec28d55891bbb6b9b6"},"name":"function_shapes_std","profile":"rust-std","program":"5156d5b2edb83f9b58b89720da3005d24bde4f212a0a5f4d25175cc4ba0628e9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable-absent/package.json b/compiler/rust/rust-std/graph-reachable-absent/package.json index 60f81c080..f29ad489b 100644 --- a/compiler/rust/rust-std/graph-reachable-absent/package.json +++ b/compiler/rust/rust-std/graph-reachable-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable-absent/provenance.json b/compiler/rust/rust-std/graph-reachable-absent/provenance.json index cc0e877a6..7f6acef77 100644 --- a/compiler/rust/rust-std/graph-reachable-absent/provenance.json +++ b/compiler/rust/rust-std/graph-reachable-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0b2894d1c10b616bb5180d7a2efbdf1c8607ca584feee908c6d54f4920aac040","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_absent_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0b2894d1c10b616bb5180d7a2efbdf1c8607ca584feee908c6d54f4920aac040","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_absent_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable-inner/package.json b/compiler/rust/rust-std/graph-reachable-inner/package.json index 0c974464b..5407a886a 100644 --- a/compiler/rust/rust-std/graph-reachable-inner/package.json +++ b/compiler/rust/rust-std/graph-reachable-inner/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_inner_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_inner_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable-inner/provenance.json b/compiler/rust/rust-std/graph-reachable-inner/provenance.json index 414e1a987..1818d66d1 100644 --- a/compiler/rust/rust-std/graph-reachable-inner/provenance.json +++ b/compiler/rust/rust-std/graph-reachable-inner/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8e23f25f2becada80c24b87f98b3606a48517046b5bdea38ff315b03d171cbf9","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_inner_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8e23f25f2becada80c24b87f98b3606a48517046b5bdea38ff315b03d171cbf9","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_inner_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable/package.json b/compiler/rust/rust-std/graph-reachable/package.json index 4691e76b0..8041f51fc 100644 --- a/compiler/rust/rust-std/graph-reachable/package.json +++ b/compiler/rust/rust-std/graph-reachable/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_reachable_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":4,"kind":"call","operands":[{"kind":"var","name":1},{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":9,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"function":12,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"function":13,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-reachable/provenance.json b/compiler/rust/rust-std/graph-reachable/provenance.json index 3b1ff9d56..c379b0d86 100644 --- a/compiler/rust/rust-std/graph-reachable/provenance.json +++ b/compiler/rust/rust-std/graph-reachable/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"da47a0ccbd1ff7c07b1e4aff98e6b080304e153038cd3e7bb28d4cb5f4c26b74","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"da47a0ccbd1ff7c07b1e4aff98e6b080304e153038cd3e7bb28d4cb5f4c26b74","src/lib.rs":"e0f9f9498cc48964b8d873933bf9113da118746f98f1f0c609706161114d0e3c"},"name":"graph_reachable_std","profile":"rust-std","program":"041e81a39e799bfc6ec17b360f2f9379382345aae6466d5338d3027f5523baa0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-successors-absent/package.json b/compiler/rust/rust-std/graph-successors-absent/package.json index 051ae75ec..cdecf9612 100644 --- a/compiler/rust/rust-std/graph-successors-absent/package.json +++ b/compiler/rust/rust-std/graph-successors-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_successors_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_successors_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-successors-absent/provenance.json b/compiler/rust/rust-std/graph-successors-absent/provenance.json index 5996c3152..a4e112a31 100644 --- a/compiler/rust/rust-std/graph-successors-absent/provenance.json +++ b/compiler/rust/rust-std/graph-successors-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"42089a95d945ae662acd664bfb0f90af87d5e25c8a365451632dc8da2d430db8","src/lib.rs":"0aa41c3a86d4fc8e40515711e0b344cd496cd95682297d865508cb1604c87cb3"},"name":"graph_successors_absent_std","profile":"rust-std","program":"8b3c90ca61d51f5e057122592afdc93c1514acbc9954325abc0b9fbca01152ef","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"42089a95d945ae662acd664bfb0f90af87d5e25c8a365451632dc8da2d430db8","src/lib.rs":"0aa41c3a86d4fc8e40515711e0b344cd496cd95682297d865508cb1604c87cb3"},"name":"graph_successors_absent_std","profile":"rust-std","program":"8b3c90ca61d51f5e057122592afdc93c1514acbc9954325abc0b9fbca01152ef","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-successors/package.json b/compiler/rust/rust-std/graph-successors/package.json index d1d704d30..5ae243eed 100644 --- a/compiler/rust/rust-std/graph-successors/package.json +++ b/compiler/rust/rust-std/graph-successors/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_successors_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"graph_successors_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-successors/provenance.json b/compiler/rust/rust-std/graph-successors/provenance.json index 4e5c9cbb3..ea214d197 100644 --- a/compiler/rust/rust-std/graph-successors/provenance.json +++ b/compiler/rust/rust-std/graph-successors/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75e8b7813e553c19915e4c083ffa0b27ea15889775d0f0b756afb3f7f8071f52","src/lib.rs":"0aa41c3a86d4fc8e40515711e0b344cd496cd95682297d865508cb1604c87cb3"},"name":"graph_successors_std","profile":"rust-std","program":"8b3c90ca61d51f5e057122592afdc93c1514acbc9954325abc0b9fbca01152ef","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75e8b7813e553c19915e4c083ffa0b27ea15889775d0f0b756afb3f7f8071f52","src/lib.rs":"0aa41c3a86d4fc8e40515711e0b344cd496cd95682297d865508cb1604c87cb3"},"name":"graph_successors_std","profile":"rust-std","program":"8b3c90ca61d51f5e057122592afdc93c1514acbc9954325abc0b9fbca01152ef","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-topological-cycle/package.json b/compiler/rust/rust-std/graph-topological-cycle/package.json index e117fe958..44711a732 100644 --- a/compiler/rust/rust-std/graph-topological-cycle/package.json +++ b/compiler/rust/rust-std/graph-topological-cycle/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"graph_topological_cycle_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"graph_topological_cycle_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-topological-cycle/provenance.json b/compiler/rust/rust-std/graph-topological-cycle/provenance.json index 376bcf0d7..5f59d8307 100644 --- a/compiler/rust/rust-std/graph-topological-cycle/provenance.json +++ b/compiler/rust/rust-std/graph-topological-cycle/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bdfec0f1b193227451cb08f1aea9afe7297d425e41cd2fa6267e8cd22daeaee1","src/lib.rs":"c51b0abc58eceaf1d8ec17c5ab25145b5987ed7e14f741b44560d6726b6cdca4"},"name":"graph_topological_cycle_std","profile":"rust-std","program":"f9745fab4349647798801c4e66ecead44a5242a05bdb373aae5e5f102c659e5f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"bdfec0f1b193227451cb08f1aea9afe7297d425e41cd2fa6267e8cd22daeaee1","src/lib.rs":"c51b0abc58eceaf1d8ec17c5ab25145b5987ed7e14f741b44560d6726b6cdca4"},"name":"graph_topological_cycle_std","profile":"rust-std","program":"f9745fab4349647798801c4e66ecead44a5242a05bdb373aae5e5f102c659e5f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-topological/package.json b/compiler/rust/rust-std/graph-topological/package.json index 82b5175e3..03599867e 100644 --- a/compiler/rust/rust-std/graph-topological/package.json +++ b/compiler/rust/rust-std/graph-topological/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"graph_topological_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"graph_topological_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/graph-topological/provenance.json b/compiler/rust/rust-std/graph-topological/provenance.json index 96f5a2e76..e187e2c14 100644 --- a/compiler/rust/rust-std/graph-topological/provenance.json +++ b/compiler/rust/rust-std/graph-topological/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0538685cbe3e01d2e8df62cd2eaa6b557850a54d1562ac4893a7a7fb9f27d410","src/lib.rs":"c51b0abc58eceaf1d8ec17c5ab25145b5987ed7e14f741b44560d6726b6cdca4"},"name":"graph_topological_std","profile":"rust-std","program":"f9745fab4349647798801c4e66ecead44a5242a05bdb373aae5e5f102c659e5f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0538685cbe3e01d2e8df62cd2eaa6b557850a54d1562ac4893a7a7fb9f27d410","src/lib.rs":"c51b0abc58eceaf1d8ec17c5ab25145b5987ed7e14f741b44560d6726b6cdca4"},"name":"graph_topological_std","profile":"rust-std","program":"f9745fab4349647798801c4e66ecead44a5242a05bdb373aae5e5f102c659e5f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-arithmetic/package.json b/compiler/rust/rust-std/int-arithmetic/package.json index 46425116c..56e7b9448 100644 --- a/compiler/rust/rust-std/int-arithmetic/package.json +++ b/compiler/rust/rust-std/int-arithmetic/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_arithmetic_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"3"}}],"operation":{"kind":"int_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"3"}}],"operation":{"kind":"int_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-4"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"6"}}],"operation":{"kind":"int_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}}],"operation":{"kind":"int_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"4"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"int"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_arithmetic_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"3"}}],"operation":{"kind":"int_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"3"}}],"operation":{"kind":"int_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-4"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"6"}}],"operation":{"kind":"int_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}}],"operation":{"kind":"int_neg"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-2"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"4"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}}],"operation":{"kind":"int_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"7"}}],"operation":{"kind":"int_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"parameters":[],"result":{"element":{"kind":"int"},"kind":"list"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-arithmetic/provenance.json b/compiler/rust/rust-std/int-arithmetic/provenance.json index 8e116cf6c..dc6cf9f28 100644 --- a/compiler/rust/rust-std/int-arithmetic/provenance.json +++ b/compiler/rust/rust-std/int-arithmetic/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3912b5dd8d90f16cf7f3f96dc90dedbcfe40f29bf8db40b02503eb2cefe1549f","src/lib.rs":"2adbdbbec80a62be6202aeb2962daf4e485f3aba019021c904ee5c22ddb38f1c"},"name":"int_arithmetic_std","profile":"rust-std","program":"74490a35f7912610de983120cac89d47c5a80a56f2d22398ebe0d116219ac822","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3912b5dd8d90f16cf7f3f96dc90dedbcfe40f29bf8db40b02503eb2cefe1549f","src/lib.rs":"2adbdbbec80a62be6202aeb2962daf4e485f3aba019021c904ee5c22ddb38f1c"},"name":"int_arithmetic_std","profile":"rust-std","program":"74490a35f7912610de983120cac89d47c5a80a56f2d22398ebe0d116219ac822","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-mul/package.json b/compiler/rust/rust-std/int-overflow-mul/package.json index 9ec4698b9..02c3954db 100644 --- a/compiler/rust/rust-std/int-overflow-mul/package.json +++ b/compiler/rust/rust-std/int-overflow-mul/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_mul_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}}],"operation":{"kind":"int_mul"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_mul_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"9223372036854775807"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"2"}}],"operation":{"kind":"int_mul"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-mul/provenance.json b/compiler/rust/rust-std/int-overflow-mul/provenance.json index 399607ba1..9af7e9dad 100644 --- a/compiler/rust/rust-std/int-overflow-mul/provenance.json +++ b/compiler/rust/rust-std/int-overflow-mul/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b1f26995a0ca536b6104f6ad4d8d528a98c58a03886b3cb976eca90ed9c62366","src/lib.rs":"e39c37c7dc031d658fc2300157b14c0df61ddbcb1694492c6817f4b6ad9c5676"},"name":"int_overflow_mul_std","profile":"rust-std","program":"1b65e9c0d0ec40bd0d8f70b9b32771560c2418a33777717ce781aca86a2ec51c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b1f26995a0ca536b6104f6ad4d8d528a98c58a03886b3cb976eca90ed9c62366","src/lib.rs":"e39c37c7dc031d658fc2300157b14c0df61ddbcb1694492c6817f4b6ad9c5676"},"name":"int_overflow_mul_std","profile":"rust-std","program":"1b65e9c0d0ec40bd0d8f70b9b32771560c2418a33777717ce781aca86a2ec51c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-neg/package.json b/compiler/rust/rust-std/int-overflow-neg/package.json index 37647feec..08f485a49 100644 --- a/compiler/rust/rust-std/int-overflow-neg/package.json +++ b/compiler/rust/rust-std/int-overflow-neg/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_neg_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_neg"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_neg_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}}],"operation":{"kind":"int_neg"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-neg/provenance.json b/compiler/rust/rust-std/int-overflow-neg/provenance.json index 1820bc818..cabb06843 100644 --- a/compiler/rust/rust-std/int-overflow-neg/provenance.json +++ b/compiler/rust/rust-std/int-overflow-neg/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"48139720f49abbee04a31a60c01a06fa0711a314acccefb2df2fe9612375465d","src/lib.rs":"d2e970c895a57f0ad211e923467b7176fe2e167ab59e1d0183ef230108b6a00f"},"name":"int_overflow_neg_std","profile":"rust-std","program":"d9fbf0bb602a1238f9d26866ce0b3b6c6b2aaeef713f2a3912ee3377f9a21523","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"48139720f49abbee04a31a60c01a06fa0711a314acccefb2df2fe9612375465d","src/lib.rs":"d2e970c895a57f0ad211e923467b7176fe2e167ab59e1d0183ef230108b6a00f"},"name":"int_overflow_neg_std","profile":"rust-std","program":"d9fbf0bb602a1238f9d26866ce0b3b6c6b2aaeef713f2a3912ee3377f9a21523","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-quot/package.json b/compiler/rust/rust-std/int-overflow-quot/package.json index cd617cd94..979398887 100644 --- a/compiler/rust/rust-std/int-overflow-quot/package.json +++ b/compiler/rust/rust-std/int-overflow-quot/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_quot_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_quot_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-1"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_quot"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-quot/provenance.json b/compiler/rust/rust-std/int-overflow-quot/provenance.json index 0c67be594..46db2234e 100644 --- a/compiler/rust/rust-std/int-overflow-quot/provenance.json +++ b/compiler/rust/rust-std/int-overflow-quot/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70ecec50cbfc19ea6d1783b7e5e38e62f4bcdc7bc48a2b0c1cb406029b1ff358","src/lib.rs":"ceacae55969aa621af4f7c53eee82890863497f39dc4bbf01645ca820e3fc410"},"name":"int_overflow_quot_std","profile":"rust-std","program":"1692b3adcca40a04933f6aebc3fea8b84cdd602624476a65e9ba90b04f7b7380","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70ecec50cbfc19ea6d1783b7e5e38e62f4bcdc7bc48a2b0c1cb406029b1ff358","src/lib.rs":"ceacae55969aa621af4f7c53eee82890863497f39dc4bbf01645ca820e3fc410"},"name":"int_overflow_quot_std","profile":"rust-std","program":"1692b3adcca40a04933f6aebc3fea8b84cdd602624476a65e9ba90b04f7b7380","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-sub/package.json b/compiler/rust/rust-std/int-overflow-sub/package.json index 81c97dae7..9341821e8 100644 --- a/compiler/rust/rust-std/int-overflow-sub/package.json +++ b/compiler/rust/rust-std/int-overflow-sub/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_sub_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_sub"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"int_overflow_sub_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_sub"}},"parameters":[],"result":{"kind":"int"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/int-overflow-sub/provenance.json b/compiler/rust/rust-std/int-overflow-sub/provenance.json index 75dbd338a..f9500c815 100644 --- a/compiler/rust/rust-std/int-overflow-sub/provenance.json +++ b/compiler/rust/rust-std/int-overflow-sub/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d136f543104a9d2e33514775925d7a9888f80f24c925561daea0503ae6aae6d9","src/lib.rs":"bc4de8365b8317da6a29d4caee4e6d5a35f3e09eb574ba1e3b600af7dc850f21"},"name":"int_overflow_sub_std","profile":"rust-std","program":"1e4e6f4192ceb578c2a360bce823d1c1aa01db87a593efa4ac989ee1d3dbb168","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d136f543104a9d2e33514775925d7a9888f80f24c925561daea0503ae6aae6d9","src/lib.rs":"bc4de8365b8317da6a29d4caee4e6d5a35f3e09eb574ba1e3b600af7dc850f21"},"name":"int_overflow_sub_std","profile":"rust-std","program":"1e4e6f4192ceb578c2a360bce823d1c1aa01db87a593efa4ac989ee1d3dbb168","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate-until-bounded/package.json b/compiler/rust/rust-std/iterate-until-bounded/package.json index becb7cb3c..d671556b7 100644 --- a/compiler/rust/rust-std/iterate-until-bounded/package.json +++ b/compiler/rust/rust-std/iterate-until-bounded/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_bounded_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_bounded_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate-until-bounded/provenance.json b/compiler/rust/rust-std/iterate-until-bounded/provenance.json index 21971e427..fc79ca417 100644 --- a/compiler/rust/rust-std/iterate-until-bounded/provenance.json +++ b/compiler/rust/rust-std/iterate-until-bounded/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ee140028333f5242547bbd85a2b8d54702b6e2ba3667ddbeef4b5d6b9d819bc3","src/lib.rs":"f5c52af9a85516cfdcc6e80bd6b0547e63a683ebce6837efb443f23dea4b9817"},"name":"iterate_until_bounded_std","profile":"rust-std","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ee140028333f5242547bbd85a2b8d54702b6e2ba3667ddbeef4b5d6b9d819bc3","src/lib.rs":"f5c52af9a85516cfdcc6e80bd6b0547e63a683ebce6837efb443f23dea4b9817"},"name":"iterate_until_bounded_std","profile":"rust-std","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate-until/package.json b/compiler/rust/rust-std/iterate-until/package.json index 7be5b5a87..b8376ff17 100644 --- a/compiler/rust/rust-std/iterate-until/package.json +++ b/compiler/rust/rust-std/iterate-until/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_until_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate-until/provenance.json b/compiler/rust/rust-std/iterate-until/provenance.json index 9e90fe691..780f91051 100644 --- a/compiler/rust/rust-std/iterate-until/provenance.json +++ b/compiler/rust/rust-std/iterate-until/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5beaded8ae28b4f2bf60cbd1f89f1af4acbcc5f3732efbc80dc60377fa7f0e37","src/lib.rs":"f5c52af9a85516cfdcc6e80bd6b0547e63a683ebce6837efb443f23dea4b9817"},"name":"iterate_until_std","profile":"rust-std","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5beaded8ae28b4f2bf60cbd1f89f1af4acbcc5f3732efbc80dc60377fa7f0e37","src/lib.rs":"f5c52af9a85516cfdcc6e80bd6b0547e63a683ebce6837efb443f23dea4b9817"},"name":"iterate_until_std","profile":"rust-std","program":"933ed0017ae24e1b179af5f2624474a367dab0414bfc90db4f456ec1f3f54e8a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate/package.json b/compiler/rust/rust-std/iterate/package.json index 8b260d9f3..95eb6e2e9 100644 --- a/compiler/rust/rust-std/iterate/package.json +++ b/compiler/rust/rust-std/iterate/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"iterate_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/iterate/provenance.json b/compiler/rust/rust-std/iterate/provenance.json index c3aa9033b..128136dc5 100644 --- a/compiler/rust/rust-std/iterate/provenance.json +++ b/compiler/rust/rust-std/iterate/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"de5e3eccc209f817965fe1ad22fe279b7b53ee8e98f0d7db012c96d31fc537a5","src/lib.rs":"5d451605ced8820aa8a88d0abb178655645ae80d417d2fb2ac53938266c4ddc0"},"name":"iterate_std","profile":"rust-std","program":"93495cb93bd9292be524f0e8414d7b827b60f812c842ab717fef46322758cf60","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"de5e3eccc209f817965fe1ad22fe279b7b53ee8e98f0d7db012c96d31fc537a5","src/lib.rs":"5d451605ced8820aa8a88d0abb178655645ae80d417d2fb2ac53938266c4ddc0"},"name":"iterate_std","profile":"rust-std","program":"93495cb93bd9292be524f0e8414d7b827b60f812c842ab717fef46322758cf60","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/list-append-long/package.json b/compiler/rust/rust-std/list-append-long/package.json index 54f6f8224..bd51bf0ad 100644 --- a/compiler/rust/rust-std/list-append-long/package.json +++ b/compiler/rust/rust-std/list-append-long/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"list_append_long_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"append"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"list_append_long_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"append"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/list-append-long/provenance.json b/compiler/rust/rust-std/list-append-long/provenance.json index 35a010bfc..268e48822 100644 --- a/compiler/rust/rust-std/list-append-long/provenance.json +++ b/compiler/rust/rust-std/list-append-long/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"93d1a8d4386d26dc94e93d98d6b3a6cc4600e57bf96756bd2f3c9eb1299b3a67","src/lib.rs":"1ca63cf500f9c44fecb3d73abed05dffcc0d60e6c0cde7ce93770e8832eb2689"},"name":"list_append_long_std","profile":"rust-std","program":"cb41d13830f113f3c6e79e5b8ac4b5766e5950f96132f30c46ae597f2e3586df","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"93d1a8d4386d26dc94e93d98d6b3a6cc4600e57bf96756bd2f3c9eb1299b3a67","src/lib.rs":"1ca63cf500f9c44fecb3d73abed05dffcc0d60e6c0cde7ce93770e8832eb2689"},"name":"list_append_long_std","profile":"rust-std","program":"cb41d13830f113f3c6e79e5b8ac4b5766e5950f96132f30c46ae597f2e3586df","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/list-fold/package.json b/compiler/rust/rust-std/list-fold/package.json index 65d53ba46..512bf015d 100644 --- a/compiler/rust/rust-std/list-fold/package.json +++ b/compiler/rust/rust-std/list-fold/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"list_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"string"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_mul"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"string"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"string"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"list_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"string"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_mul"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"string"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"string"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/list-fold/provenance.json b/compiler/rust/rust-std/list-fold/provenance.json index cbf8d1444..75b1fe6bf 100644 --- a/compiler/rust/rust-std/list-fold/provenance.json +++ b/compiler/rust/rust-std/list-fold/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f3400f1bb065c95570809435d17afa7f43f5b6d210165450bd749d33dc15fc4e","src/lib.rs":"fe2e803b29ade977a8cadf5ff0e59bd0db2f013c41a2d17ca7432880dfa2779c"},"name":"list_fold_std","profile":"rust-std","program":"2aa5c562412f19a36dc6871936614db4c9fcffb88ac2dc090b7a8113b4062d0d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f3400f1bb065c95570809435d17afa7f43f5b6d210165450bd749d33dc15fc4e","src/lib.rs":"fe2e803b29ade977a8cadf5ff0e59bd0db2f013c41a2d17ca7432880dfa2779c"},"name":"list_fold_std","profile":"rust-std","program":"2aa5c562412f19a36dc6871936614db4c9fcffb88ac2dc090b7a8113b4062d0d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/lists-borrowed/package.json b/compiler/rust/rust-std/lists-borrowed/package.json index 04c179fc8..9ccb84155 100644 --- a/compiler/rust/rust-std/lists-borrowed/package.json +++ b/compiler/rust/rust-std/lists-borrowed/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["borrow"]}],"name":"lists_borrowed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["borrow"]}],"name":"lists_borrowed_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/lists-borrowed/provenance.json b/compiler/rust/rust-std/lists-borrowed/provenance.json index 25c31b996..8ad7781fe 100644 --- a/compiler/rust/rust-std/lists-borrowed/provenance.json +++ b/compiler/rust/rust-std/lists-borrowed/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"01ec12b89f6a1df6e0fdc7c9b3b0a981bc8b7c530d46f1befb9dc3da9bbd3344","src/lib.rs":"563ca680f395a8843b904d29481e17efcda374d28eaf912235792eb8858ae858"},"name":"lists_borrowed_std","profile":"rust-std","program":"6ccce5df53085556ae8de4d7783d2b5f3734fdee0f895ed7c612b695af1b208e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"01ec12b89f6a1df6e0fdc7c9b3b0a981bc8b7c530d46f1befb9dc3da9bbd3344","src/lib.rs":"563ca680f395a8843b904d29481e17efcda374d28eaf912235792eb8858ae858"},"name":"lists_borrowed_std","profile":"rust-std","program":"6ccce5df53085556ae8de4d7783d2b5f3734fdee0f895ed7c612b695af1b208e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/lists/package.json b/compiler/rust/rust-std/lists/package.json index 368c2cde5..9ce9a6466 100644 --- a/compiler/rust/rust-std/lists/package.json +++ b/compiler/rust/rust-std/lists/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"lists_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"lists_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"parameters":[0],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/lists/provenance.json b/compiler/rust/rust-std/lists/provenance.json index 5caa72e8b..12b92a5f1 100644 --- a/compiler/rust/rust-std/lists/provenance.json +++ b/compiler/rust/rust-std/lists/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"20a5e788febf3f6995f85883485d6e561b1d12dfa390f426c37a4676b4c7e6bd","src/lib.rs":"f658b6c437ef639208128f85ab4caf2c83fa4a1243d700fd8384d12bd4d504a4"},"name":"lists_std","profile":"rust-std","program":"6ccce5df53085556ae8de4d7783d2b5f3734fdee0f895ed7c612b695af1b208e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"20a5e788febf3f6995f85883485d6e561b1d12dfa390f426c37a4676b4c7e6bd","src/lib.rs":"f658b6c437ef639208128f85ab4caf2c83fa4a1243d700fd8384d12bd4d504a4"},"name":"lists_std","profile":"rust-std","program":"6ccce5df53085556ae8de4d7783d2b5f3734fdee0f895ed7c612b695af1b208e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/literals/package.json b/compiler/rust/rust-std/literals/package.json index 3a2d79c66..ab0c22708 100644 --- a/compiler/rust/rust-std/literals/package.json +++ b/compiler/rust/rust-std/literals/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"literals_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"unit"},{"kind":"bool"},{"kind":"nat"},{"kind":"int"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i64"},{"kind":"string"},{"kind":"bytes"},{"kind":"ordering"},{"kind":"option","value":{"kind":"nat"}},{"kind":"option","value":{"kind":"bool"}},{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"index":1,"kind":"adt"}]]},{"constructors":[[],[{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"unit"},"value":{"kind":"unit"}},{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":true}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32768"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483648"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"snow ☃"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff7f","kind":"bytes"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"eq"}},{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}},{"kind":"value","type":{"kind":"option","value":{"kind":"bool"}},"value":{"kind":"some","value":{"kind":"bool","value":false}}},{"kind":"value","type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"error","value":{"kind":"string","value":"no"}}},{"kind":"value","type":{"element":{"kind":"nat"},"kind":"list"},"value":{"items":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"list"}},{"kind":"value","type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"value":{"kind":"pair","left":{"kind":"nat","value":"3"},"right":{"kind":"string","value":"three"}}},{"kind":"value","type":{"index":1,"kind":"adt"},"value":{"constructor":1,"fields":[{"kind":"nat","value":"5"}],"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"literals_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"unit"},{"kind":"bool"},{"kind":"nat"},{"kind":"int"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u64"},{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"},{"kind":"fixed","width":"i64"},{"kind":"string"},{"kind":"bytes"},{"kind":"ordering"},{"kind":"option","value":{"kind":"nat"}},{"kind":"option","value":{"kind":"bool"}},{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},{"element":{"kind":"nat"},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"index":1,"kind":"adt"}]]},{"constructors":[[],[{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"unit"},"value":{"kind":"unit"}},{"kind":"value","type":{"kind":"bool"},"value":{"kind":"bool","value":true}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"255"}},{"kind":"value","type":{"kind":"fixed","width":"u16"},"value":{"kind":"u16","value":"65535"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4294967295"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"fixed","width":"i8"},"value":{"kind":"i8","value":"-128"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-32768"}},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-2147483648"}},{"kind":"value","type":{"kind":"fixed","width":"i64"},"value":{"kind":"i64","value":"-9223372036854775808"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"snow ☃"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff7f","kind":"bytes"}},{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"eq"}},{"kind":"value","type":{"kind":"option","value":{"kind":"nat"}},"value":{"kind":"none"}},{"kind":"value","type":{"kind":"option","value":{"kind":"bool"}},"value":{"kind":"some","value":{"kind":"bool","value":false}}},{"kind":"value","type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"ok","value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"error":{"kind":"string"},"kind":"result","ok":{"kind":"nat"}},"value":{"kind":"error","value":{"kind":"string","value":"no"}}},{"kind":"value","type":{"element":{"kind":"nat"},"kind":"list"},"value":{"items":[{"kind":"nat","value":"1"},{"kind":"nat","value":"2"}],"kind":"list"}},{"kind":"value","type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"value":{"kind":"pair","left":{"kind":"nat","value":"3"},"right":{"kind":"string","value":"three"}}},{"kind":"value","type":{"index":1,"kind":"adt"},"value":{"constructor":1,"fields":[{"kind":"nat","value":"5"}],"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[],"result":{"index":0,"kind":"adt"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/literals/provenance.json b/compiler/rust/rust-std/literals/provenance.json index f53b0ec09..e76742ee1 100644 --- a/compiler/rust/rust-std/literals/provenance.json +++ b/compiler/rust/rust-std/literals/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0967689a42ab9a6bdcfba8e93c74e0293cda460413bb245ec0b39aa1e2b5a2ca","src/lib.rs":"929569285659bc8ab598f7239e30b103056ee70f74bd2b69daca22764355f294"},"name":"literals_std","profile":"rust-std","program":"2c3026cfe7aae0d5cdd2a0c9ac2ba5174566b5aa92ebdb3a069953cffc7178aa","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0967689a42ab9a6bdcfba8e93c74e0293cda460413bb245ec0b39aa1e2b5a2ca","src/lib.rs":"929569285659bc8ab598f7239e30b103056ee70f74bd2b69daca22764355f294"},"name":"literals_std","profile":"rust-std","program":"2c3026cfe7aae0d5cdd2a0c9ac2ba5174566b5aa92ebdb3a069953cffc7178aa","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-contains/package.json b/compiler/rust/rust-std/map-contains/package.json index 2930cf06d..dd4fba63b 100644 --- a/compiler/rust/rust-std/map-contains/package.json +++ b/compiler/rust/rust-std/map-contains/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_contains_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_contains_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-contains/provenance.json b/compiler/rust/rust-std/map-contains/provenance.json index c54e6b4d7..77c2bd54a 100644 --- a/compiler/rust/rust-std/map-contains/provenance.json +++ b/compiler/rust/rust-std/map-contains/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce447f41f31637f37caf9685507d57dbbec7a9838715fe8c6ac4defc594791b6","src/lib.rs":"88e3fd1de99645c19db740404d9388da840543994a417a0a8f069052b2cd45d3"},"name":"map_contains_std","profile":"rust-std","program":"df72d86cdcf4f1ec907202221da90c365a110f9ad9a04027d440ef0791bf98d0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce447f41f31637f37caf9685507d57dbbec7a9838715fe8c6ac4defc594791b6","src/lib.rs":"88e3fd1de99645c19db740404d9388da840543994a417a0a8f069052b2cd45d3"},"name":"map_contains_std","profile":"rust-std","program":"df72d86cdcf4f1ec907202221da90c365a110f9ad9a04027d440ef0791bf98d0","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-fold/package.json b/compiler/rust/rust-std/map-fold/package.json index fd19be6e1..b3cd51f06 100644 --- a/compiler/rust/rust-std/map-fold/package.json +++ b/compiler/rust/rust-std/map-fold/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"map_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}},{"kind":"second","value":{"kind":"var","name":3}}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"map_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}},{"kind":"second","value":{"kind":"var","name":3}}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"},{"kind":"string"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-fold/provenance.json b/compiler/rust/rust-std/map-fold/provenance.json index aeb298b2d..89ffccd9c 100644 --- a/compiler/rust/rust-std/map-fold/provenance.json +++ b/compiler/rust/rust-std/map-fold/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"acd3221748be57ca02c0c93ab3c62c29e381c2b61efe6580fba612c28f379fa3","src/lib.rs":"583d7fceb7d79922f310fbc134c58646916187c1f9066d2b61bad72e1d816b0b"},"name":"map_fold_std","profile":"rust-std","program":"63b90078766cb65f800cd8a26affe5549439339580190e43f94bd40e77c44ae9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"acd3221748be57ca02c0c93ab3c62c29e381c2b61efe6580fba612c28f379fa3","src/lib.rs":"583d7fceb7d79922f310fbc134c58646916187c1f9066d2b61bad72e1d816b0b"},"name":"map_fold_std","profile":"rust-std","program":"63b90078766cb65f800cd8a26affe5549439339580190e43f94bd40e77c44ae9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert-last/package.json b/compiler/rust/rust-std/map-insert-last/package.json index 06c4b3419..d87a21022 100644 --- a/compiler/rust/rust-std/map-insert-last/package.json +++ b/compiler/rust/rust-std/map-insert-last/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_last_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_last_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert-last/provenance.json b/compiler/rust/rust-std/map-insert-last/provenance.json index 67c5b11fa..4aabac897 100644 --- a/compiler/rust/rust-std/map-insert-last/provenance.json +++ b/compiler/rust/rust-std/map-insert-last/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f8618383f2124ef08ead6b647ca07d17cd0fc89e6fd3788e1b0621caf42d774","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_last_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f8618383f2124ef08ead6b647ca07d17cd0fc89e6fd3788e1b0621caf42d774","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_last_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert-replace/package.json b/compiler/rust/rust-std/map-insert-replace/package.json index b99d38100..988704d57 100644 --- a/compiler/rust/rust-std/map-insert-replace/package.json +++ b/compiler/rust/rust-std/map-insert-replace/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_replace_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_replace_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert-replace/provenance.json b/compiler/rust/rust-std/map-insert-replace/provenance.json index f217c514f..7b7a4f933 100644 --- a/compiler/rust/rust-std/map-insert-replace/provenance.json +++ b/compiler/rust/rust-std/map-insert-replace/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4e3afd163bad1322c23b861692ee6e15998741fb5dbf234985415b3cd9185f25","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_replace_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4e3afd163bad1322c23b861692ee6e15998741fb5dbf234985415b3cd9185f25","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_replace_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert/package.json b/compiler/rust/rust-std/map-insert/package.json index dbf2cab10..5d0eeec75 100644 --- a/compiler/rust/rust-std/map-insert/package.json +++ b/compiler/rust/rust-std/map-insert/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"map_insert_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-insert/provenance.json b/compiler/rust/rust-std/map-insert/provenance.json index 516a7d3bb..230b6355c 100644 --- a/compiler/rust/rust-std/map-insert/provenance.json +++ b/compiler/rust/rust-std/map-insert/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8cd5b6cabaa16bbfb42573a6909a72db39ceead8cc4f57f1128d6e3ff7717895","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8cd5b6cabaa16bbfb42573a6909a72db39ceead8cc4f57f1128d6e3ff7717895","src/lib.rs":"aaec98e55df975f9cfe92f9af0029672221cf16f34376b04f17d9067ec2aa258"},"name":"map_insert_std","profile":"rust-std","program":"5a01e58fc0d604993996bb97ea9ae231bdf42b95ffc1e1a14babe6a9f9760146","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-keys/package.json b/compiler/rust/rust-std/map-keys/package.json index 34a1c4901..d5f7061c7 100644 --- a/compiler/rust/rust-std/map-keys/package.json +++ b/compiler/rust/rust-std/map-keys/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"map_keys_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"map_keys_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-keys/provenance.json b/compiler/rust/rust-std/map-keys/provenance.json index c6730b7df..faba212e2 100644 --- a/compiler/rust/rust-std/map-keys/provenance.json +++ b/compiler/rust/rust-std/map-keys/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9a54e4fad0cbdaed5584a08314a193ff57dd32021316c1dd556511e541965ede","src/lib.rs":"9eb502c8b15d3fcfbb95a53990d6397bdc83c6c8015311c1dc594aac2cf591f0"},"name":"map_keys_std","profile":"rust-std","program":"1e925223f9489bafbe49be0806a77d50daa7d530901c0996aa7fcdff8c722000","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9a54e4fad0cbdaed5584a08314a193ff57dd32021316c1dd556511e541965ede","src/lib.rs":"9eb502c8b15d3fcfbb95a53990d6397bdc83c6c8015311c1dc594aac2cf591f0"},"name":"map_keys_std","profile":"rust-std","program":"1e925223f9489bafbe49be0806a77d50daa7d530901c0996aa7fcdff8c722000","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-lookup-absent/package.json b/compiler/rust/rust-std/map-lookup-absent/package.json index 81ddcb375..bf39834b3 100644 --- a/compiler/rust/rust-std/map-lookup-absent/package.json +++ b/compiler/rust/rust-std/map-lookup-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_lookup_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_lookup_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-lookup-absent/provenance.json b/compiler/rust/rust-std/map-lookup-absent/provenance.json index f6d46ee14..cf746dcef 100644 --- a/compiler/rust/rust-std/map-lookup-absent/provenance.json +++ b/compiler/rust/rust-std/map-lookup-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5e325a7730ab6428120698b0da48e7862add0fb1259c1b40fdad9eb9401c285b","src/lib.rs":"e9feece1646c9b1991285d88596061f5ddf6356621e9537025f3dcd85742ca29"},"name":"map_lookup_absent_std","profile":"rust-std","program":"5836c1d18da2bb1aafa25ef6128410fa43467be15a9530d1244cff1678d7c9a9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5e325a7730ab6428120698b0da48e7862add0fb1259c1b40fdad9eb9401c285b","src/lib.rs":"e9feece1646c9b1991285d88596061f5ddf6356621e9537025f3dcd85742ca29"},"name":"map_lookup_absent_std","profile":"rust-std","program":"5836c1d18da2bb1aafa25ef6128410fa43467be15a9530d1244cff1678d7c9a9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-lookup/package.json b/compiler/rust/rust-std/map-lookup/package.json index ba45351f5..9f742cf13 100644 --- a/compiler/rust/rust-std/map-lookup/package.json +++ b/compiler/rust/rust-std/map-lookup/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_lookup_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_lookup_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"string"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"string"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-lookup/provenance.json b/compiler/rust/rust-std/map-lookup/provenance.json index ecbb01a0b..61dd612df 100644 --- a/compiler/rust/rust-std/map-lookup/provenance.json +++ b/compiler/rust/rust-std/map-lookup/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6da1f98af3cd5fd00b1ef2306204a56a335c7fa779fdd526238e546a80808d29","src/lib.rs":"e9feece1646c9b1991285d88596061f5ddf6356621e9537025f3dcd85742ca29"},"name":"map_lookup_std","profile":"rust-std","program":"5836c1d18da2bb1aafa25ef6128410fa43467be15a9530d1244cff1678d7c9a9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6da1f98af3cd5fd00b1ef2306204a56a335c7fa779fdd526238e546a80808d29","src/lib.rs":"e9feece1646c9b1991285d88596061f5ddf6356621e9537025f3dcd85742ca29"},"name":"map_lookup_std","profile":"rust-std","program":"5836c1d18da2bb1aafa25ef6128410fa43467be15a9530d1244cff1678d7c9a9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-remove-absent/package.json b/compiler/rust/rust-std/map-remove-absent/package.json index 18ddb2b6f..bcdc5b547 100644 --- a/compiler/rust/rust-std/map-remove-absent/package.json +++ b/compiler/rust/rust-std/map-remove-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_remove_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_remove_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-remove-absent/provenance.json b/compiler/rust/rust-std/map-remove-absent/provenance.json index f098fd015..fcb27e01f 100644 --- a/compiler/rust/rust-std/map-remove-absent/provenance.json +++ b/compiler/rust/rust-std/map-remove-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5f55bd671897808bf269007a9aa515d53c8380c2b60b30ccf7b5e9cf2f3cbca8","src/lib.rs":"2f110e9c33251cb47c9bd9b5ce0834a2092737ba26c79ae8288bcbaa90a684f0"},"name":"map_remove_absent_std","profile":"rust-std","program":"14052f9d4e78410cfe25294fafa508aeea89995b11fe20f274d9e09a673c9883","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5f55bd671897808bf269007a9aa515d53c8380c2b60b30ccf7b5e9cf2f3cbca8","src/lib.rs":"2f110e9c33251cb47c9bd9b5ce0834a2092737ba26c79ae8288bcbaa90a684f0"},"name":"map_remove_absent_std","profile":"rust-std","program":"14052f9d4e78410cfe25294fafa508aeea89995b11fe20f274d9e09a673c9883","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-remove/package.json b/compiler/rust/rust-std/map-remove/package.json index 4bd86c9e3..11d801e22 100644 --- a/compiler/rust/rust-std/map-remove/package.json +++ b/compiler/rust/rust-std/map-remove/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_remove_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"map_remove_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-remove/provenance.json b/compiler/rust/rust-std/map-remove/provenance.json index 8ab91714b..0ee447e03 100644 --- a/compiler/rust/rust-std/map-remove/provenance.json +++ b/compiler/rust/rust-std/map-remove/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e594ad5e1e13afda2304aae978748aeb1fe043d0fe84b4e1d0444eb3ec2f33b4","src/lib.rs":"2f110e9c33251cb47c9bd9b5ce0834a2092737ba26c79ae8288bcbaa90a684f0"},"name":"map_remove_std","profile":"rust-std","program":"14052f9d4e78410cfe25294fafa508aeea89995b11fe20f274d9e09a673c9883","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e594ad5e1e13afda2304aae978748aeb1fe043d0fe84b4e1d0444eb3ec2f33b4","src/lib.rs":"2f110e9c33251cb47c9bd9b5ce0834a2092737ba26c79ae8288bcbaa90a684f0"},"name":"map_remove_std","profile":"rust-std","program":"14052f9d4e78410cfe25294fafa508aeea89995b11fe20f274d9e09a673c9883","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-values/package.json b/compiler/rust/rust-std/map-values/package.json index 7c9df582b..631da2082 100644 --- a/compiler/rust/rust-std/map-values/package.json +++ b/compiler/rust/rust-std/map-values/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"map_values_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"map_values_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/map-values/provenance.json b/compiler/rust/rust-std/map-values/provenance.json index 3ce098b83..2f22b9a00 100644 --- a/compiler/rust/rust-std/map-values/provenance.json +++ b/compiler/rust/rust-std/map-values/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"de84dcf781a2251130941f8019fbd4711b083bc77acd61c8f4ca19a211125745","src/lib.rs":"cca7349ebb43212df44eed3ed41779b6c4a93319fa2157052c69ce46039630ed"},"name":"map_values_std","profile":"rust-std","program":"26378f9985f96f922ee1a94bcd555bdda1e7b31d8f0e0d11d7dcc219fe9ae853","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"de84dcf781a2251130941f8019fbd4711b083bc77acd61c8f4ca19a211125745","src/lib.rs":"cca7349ebb43212df44eed3ed41779b6c4a93319fa2157052c69ce46039630ed"},"name":"map_values_std","profile":"rust-std","program":"26378f9985f96f922ee1a94bcd555bdda1e7b31d8f0e0d11d7dcc219fe9ae853","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/match-shapes/package.json b/compiler/rust/rust-std/match-shapes/package.json index c8af4ba93..3cf27bff6 100644 --- a/compiler/rust/rust-std/match-shapes/package.json +++ b/compiler/rust/rust-std/match-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"match_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"bool"}]]}],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[6],"body":{"kind":"build","operands":[{"kind":"var","name":6}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"build","operands":[{"kind":"var","name":7}],"shape":{"kind":"error"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[9],"body":{"kind":"build","operands":[{"kind":"var","name":9}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"compare"}},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[10],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":10},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[11],"body":{"kind":"build","operands":[{"kind":"var","name":11}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[12],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"none"}},{"binders":[13],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"match_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"bool"}]]}],"functions":[{"body":{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[6],"body":{"kind":"build","operands":[{"kind":"var","name":6}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[7],"body":{"kind":"build","operands":[{"kind":"var","name":7}],"shape":{"kind":"error"},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[9],"body":{"kind":"build","operands":[{"kind":"var","name":9}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"compare"}},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[10],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":10},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[11],"body":{"kind":"build","operands":[{"kind":"var","name":11}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"ok"}},{"binders":[12],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"none"}},{"binders":[13],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},"right":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"unit"}}}}}}}},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}},{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"option","value":{"kind":"nat"}}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/match-shapes/provenance.json b/compiler/rust/rust-std/match-shapes/provenance.json index f1ec94da8..ad4ad38f4 100644 --- a/compiler/rust/rust-std/match-shapes/provenance.json +++ b/compiler/rust/rust-std/match-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0fc175e8e696efab2e0974dc5539bc94654a9eeef8fcc26f11a0a4bb03f3d483","src/lib.rs":"03c28aa070c011683bbd164a59f2de77fe840f40e08512c69984460efc597b24"},"name":"match_shapes_std","profile":"rust-std","program":"9680443f3a937a999f89648157989a00a6143ddefdeb16329afe27891c3279a2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0fc175e8e696efab2e0974dc5539bc94654a9eeef8fcc26f11a0a4bb03f3d483","src/lib.rs":"03c28aa070c011683bbd164a59f2de77fe840f40e08512c69984460efc597b24"},"name":"match_shapes_std","profile":"rust-std","program":"9680443f3a937a999f89648157989a00a6143ddefdeb16329afe27891c3279a2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-arithmetic/package.json b/compiler/rust/rust-std/nat-arithmetic/package.json index 560fe29c1..5c73707c1 100644 --- a/compiler/rust/rust-std/nat-arithmetic/package.json +++ b/compiler/rust/rust-std/nat-arithmetic/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_arithmetic_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"17"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"17"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551614"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_eq"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"bool"},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"bool"},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_arithmetic_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"17"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"17"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_rem"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551614"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_eq"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"bool"},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"bool"},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-arithmetic/provenance.json b/compiler/rust/rust-std/nat-arithmetic/provenance.json index 22b400342..998f0b448 100644 --- a/compiler/rust/rust-std/nat-arithmetic/provenance.json +++ b/compiler/rust/rust-std/nat-arithmetic/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"52d874842364a98a1ec3af35151dc6553820eb61a73b729963df7c502dc45656","src/lib.rs":"b90de3b8c5e1a292e2bcd4f27fe82dd61ff975398b9cf3c6ef006692e6d7c829"},"name":"nat_arithmetic_std","profile":"rust-std","program":"18e386987a44d4e9057579c3775b66c5293ebaa332bb2cba7811f2f828c7df9c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"52d874842364a98a1ec3af35151dc6553820eb61a73b729963df7c502dc45656","src/lib.rs":"b90de3b8c5e1a292e2bcd4f27fe82dd61ff975398b9cf3c6ef006692e6d7c829"},"name":"nat_arithmetic_std","profile":"rust-std","program":"18e386987a44d4e9057579c3775b66c5293ebaa332bb2cba7811f2f828c7df9c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-add/package.json b/compiler/rust/rust-std/nat-overflow-add/package.json index 1556e88f1..c72b527a9 100644 --- a/compiler/rust/rust-std/nat-overflow-add/package.json +++ b/compiler/rust/rust-std/nat-overflow-add/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_add_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_add_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-add/provenance.json b/compiler/rust/rust-std/nat-overflow-add/provenance.json index 38881773a..9d3af3399 100644 --- a/compiler/rust/rust-std/nat-overflow-add/provenance.json +++ b/compiler/rust/rust-std/nat-overflow-add/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c7d9a73db6e119b2287af8553c30fcc2ba8490c05fe072c99b3693ab3f14c484","src/lib.rs":"f2eca38aef1cf7d204233f8bd6561803dca4fb7bfb1ec1f58caa726bbd3fc130"},"name":"nat_overflow_add_std","profile":"rust-std","program":"75136000ad8f2649db77d0237b973fea7740fa9fa28016b113d678a049dc353a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c7d9a73db6e119b2287af8553c30fcc2ba8490c05fe072c99b3693ab3f14c484","src/lib.rs":"f2eca38aef1cf7d204233f8bd6561803dca4fb7bfb1ec1f58caa726bbd3fc130"},"name":"nat_overflow_add_std","profile":"rust-std","program":"75136000ad8f2649db77d0237b973fea7740fa9fa28016b113d678a049dc353a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-mul/package.json b/compiler/rust/rust-std/nat-overflow-mul/package.json index aed58c27f..59c39ea7d 100644 --- a/compiler/rust/rust-std/nat-overflow-mul/package.json +++ b/compiler/rust/rust-std/nat-overflow-mul/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_mul_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}}],"operation":{"kind":"nat_mul"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_mul_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4294967296"}}],"operation":{"kind":"nat_mul"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-mul/provenance.json b/compiler/rust/rust-std/nat-overflow-mul/provenance.json index c79bfddb6..a722c997e 100644 --- a/compiler/rust/rust-std/nat-overflow-mul/provenance.json +++ b/compiler/rust/rust-std/nat-overflow-mul/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c51c40386c887537c3db34b43f2599c75078af2764050494c5fdbbd35c91426d","src/lib.rs":"44257ffe7458bc923269bc1c46ad8d68a93e0d55ac1743c45be328370993e5bf"},"name":"nat_overflow_mul_std","profile":"rust-std","program":"39cd232f7cdf413f7c2ca48cb08a2ba12c63d0e4cad7e882987c21ac7b2ca535","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c51c40386c887537c3db34b43f2599c75078af2764050494c5fdbbd35c91426d","src/lib.rs":"44257ffe7458bc923269bc1c46ad8d68a93e0d55ac1743c45be328370993e5bf"},"name":"nat_overflow_mul_std","profile":"rust-std","program":"39cd232f7cdf413f7c2ca48cb08a2ba12c63d0e4cad7e882987c21ac7b2ca535","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-nested/package.json b/compiler/rust/rust-std/nat-overflow-nested/package.json index 2630d205d..2ea890334 100644 --- a/compiler/rust/rust-std/nat-overflow-nested/package.json +++ b/compiler/rust/rust-std/nat-overflow-nested/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_nested_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_nested_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-nested/provenance.json b/compiler/rust/rust-std/nat-overflow-nested/provenance.json index e2bde9e76..516bca87f 100644 --- a/compiler/rust/rust-std/nat-overflow-nested/provenance.json +++ b/compiler/rust/rust-std/nat-overflow-nested/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"63ae0461075538d1b66575a4ed6deb54143cfee5157c49aeb77bf881619127b5","src/lib.rs":"bdd6ca1493a1086d5f5ad34f4ebfba15288a59a193e0f9c9f4abc8581c3a49c3"},"name":"nat_overflow_nested_std","profile":"rust-std","program":"ce3c27adceeaff5a870453e77162774541aaadbd6163b168d754ee39f964d7f9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"63ae0461075538d1b66575a4ed6deb54143cfee5157c49aeb77bf881619127b5","src/lib.rs":"bdd6ca1493a1086d5f5ad34f4ebfba15288a59a193e0f9c9f4abc8581c3a49c3"},"name":"nat_overflow_nested_std","profile":"rust-std","program":"ce3c27adceeaff5a870453e77162774541aaadbd6163b168d754ee39f964d7f9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-succ/package.json b/compiler/rust/rust-std/nat-overflow-succ/package.json index 105ffb03d..e6f429c9a 100644 --- a/compiler/rust/rust-std/nat-overflow-succ/package.json +++ b/compiler/rust/rust-std/nat-overflow-succ/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_succ_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":[]}],"name":"nat_overflow_succ_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"18446744073709551615"}}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},"parameters":[],"result":{"kind":"nat"},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/nat-overflow-succ/provenance.json b/compiler/rust/rust-std/nat-overflow-succ/provenance.json index 0b6b931d6..a7b625f01 100644 --- a/compiler/rust/rust-std/nat-overflow-succ/provenance.json +++ b/compiler/rust/rust-std/nat-overflow-succ/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aa64b611cb42944aa7f2368328114b98d0c0771ca2fb3703b7c8d04c965f0023","src/lib.rs":"08d68e1e54ea4e238b9947e1c314dee05b3f8cdb8687c14168612d9da31493c8"},"name":"nat_overflow_succ_std","profile":"rust-std","program":"71f5809a5001f094afc988a2e7a574309cd425857b135a51fbfeb799e80c9ee5","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aa64b611cb42944aa7f2368328114b98d0c0771ca2fb3703b7c8d04c965f0023","src/lib.rs":"08d68e1e54ea4e238b9947e1c314dee05b3f8cdb8687c14168612d9da31493c8"},"name":"nat_overflow_succ_std","profile":"rust-std","program":"71f5809a5001f094afc988a2e7a574309cd425857b135a51fbfeb799e80c9ee5","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/ordering/package.json b/compiler/rust/rust-std/ordering/package.json index 319aa2a72..ee904b83a 100644 --- a/compiler/rust/rust-std/ordering/package.json +++ b/compiler/rust/rust-std/ordering/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"ordering_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"5"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-5"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"b"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"gt"}},"type":{"kind":"nat"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"ordering"},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"ordering"},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"ordering_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"5"}},{"kind":"value","type":{"kind":"fixed","width":"i16"},"value":{"kind":"i16","value":"-5"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"0"}},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"é"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"b"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"string"}}}],"operation":{"kind":"compare"}},"type":{"kind":"nat"}},{"kind":"build","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"value","type":{"kind":"ordering"},"value":{"kind":"ordering","value":"gt"}},"type":{"kind":"nat"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"lt"},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"eq"},"type":{"kind":"ordering"}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"gt"},"type":{"kind":"ordering"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"ordering"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"ordering"},"kind":"list"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"ordering"},"kind":"list"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/ordering/provenance.json b/compiler/rust/rust-std/ordering/provenance.json index f28616e8d..7b52fa615 100644 --- a/compiler/rust/rust-std/ordering/provenance.json +++ b/compiler/rust/rust-std/ordering/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"142a59240c00723aa00ed298dd5b431f7f14b956d4b09b9752c4802c0d21b326","src/lib.rs":"36558853c89ae0ee0daf0aaa24d39d1b20f1d65407f2bd6d5b4ca71970460983"},"name":"ordering_std","profile":"rust-std","program":"3217967643b88e6bc78df4e90f18f31985e02fe048e60d864ef4567a410b67e4","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"142a59240c00723aa00ed298dd5b431f7f14b956d4b09b9752c4802c0d21b326","src/lib.rs":"36558853c89ae0ee0daf0aaa24d39d1b20f1d65407f2bd6d5b4ca71970460983"},"name":"ordering_std","profile":"rust-std","program":"3217967643b88e6bc78df4e90f18f31985e02fe048e60d864ef4567a410b67e4","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/pair-and-list-match/package.json b/compiler/rust/rust-std/pair-and-list-match/package.json index d772f5f09..6553da4e7 100644 --- a/compiler/rust/rust-std/pair-and-list-match/package.json +++ b/compiler/rust/rust-std/pair-and-list-match/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"pair_and_list_match_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":5}],"operation":{"kind":"nat_add"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"shape":{"kind":"pair"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"kind":"nat"}}}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"pair_and_list_match_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"none"}},{"binders":[5],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":5}],"operation":{"kind":"nat_add"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"shape":{"kind":"pair"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"kind":"nat"}}}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/pair-and-list-match/provenance.json b/compiler/rust/rust-std/pair-and-list-match/provenance.json index d02186e74..3634a0529 100644 --- a/compiler/rust/rust-std/pair-and-list-match/provenance.json +++ b/compiler/rust/rust-std/pair-and-list-match/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e0950c055dee20845f6a4ba4b9abcdaa1edb939a5a9c9896993fa947cc3728da","src/lib.rs":"44d429c4629f6b714bf018623c134c6a165f24ac81a740d6cd6f145510481eb9"},"name":"pair_and_list_match_std","profile":"rust-std","program":"64b6104291406dae5cd141de083c74e050f1bc09e350c00f0d6a6e7f59eefb09","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e0950c055dee20845f6a4ba4b9abcdaa1edb939a5a9c9896993fa947cc3728da","src/lib.rs":"44d429c4629f6b714bf018623c134c6a165f24ac81a740d6cd6f145510481eb9"},"name":"pair_and_list_match_std","profile":"rust-std","program":"64b6104291406dae5cd141de083c74e050f1bc09e350c00f0d6a6e7f59eefb09","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-dose-120/package.json b/compiler/rust/rust-std/reasoning-dose-120/package.json index e40392d8d..6e7c31f0f 100644 --- a/compiler/rust/rust-std/reasoning-dose-120/package.json +++ b/compiler/rust/rust-std/reasoning-dose-120/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_dose_120_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"nat"}},{"kind":"bool"},{"index":1,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":6,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":4,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"index":2,"kind":"field","value":{"kind":"var","name":1}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"nat"},{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"condition":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"else_branch":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":0,"kind":"adt"},{"kind":"nat"}],"result":{"index":0,"kind":"adt"}},{"index":0,"kind":"adt"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_dose_120_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"nat"}},{"kind":"bool"},{"index":1,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":6,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":4,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"index":2,"kind":"field","value":{"kind":"var","name":1}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"nat"},{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"condition":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"else_branch":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":0,"kind":"adt"},{"kind":"nat"}],"result":{"index":0,"kind":"adt"}},{"index":0,"kind":"adt"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-dose-120/provenance.json b/compiler/rust/rust-std/reasoning-dose-120/provenance.json index 4412709d8..54d87135a 100644 --- a/compiler/rust/rust-std/reasoning-dose-120/provenance.json +++ b/compiler/rust/rust-std/reasoning-dose-120/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"347ca6976c581cfc7210315f36ce0d8079179f4f8988dcf909b6110270779d7a","src/lib.rs":"d717a3caeb5fa31378975d68db7192958c9beb599c424476f857c3fd164b3e0b"},"name":"reasoning_dose_120_std","profile":"rust-std","program":"94fc260ab569c32e5f07d9b4018587bf3894f17d5f47f026fdadb127ee750c08","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"347ca6976c581cfc7210315f36ce0d8079179f4f8988dcf909b6110270779d7a","src/lib.rs":"d717a3caeb5fa31378975d68db7192958c9beb599c424476f857c3fd164b3e0b"},"name":"reasoning_dose_120_std","profile":"rust-std","program":"94fc260ab569c32e5f07d9b4018587bf3894f17d5f47f026fdadb127ee750c08","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-dose-60/package.json b/compiler/rust/rust-std/reasoning-dose-60/package.json index 532fc0340..95dc0afe9 100644 --- a/compiler/rust/rust-std/reasoning-dose-60/package.json +++ b/compiler/rust/rust-std/reasoning-dose-60/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_dose_60_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"nat"}},{"kind":"bool"},{"index":1,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":6,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":4,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"index":2,"kind":"field","value":{"kind":"var","name":1}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"nat"},{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"condition":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"else_branch":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":0,"kind":"adt"},{"kind":"nat"}],"result":{"index":0,"kind":"adt"}},{"index":0,"kind":"adt"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_dose_60_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"option","value":{"kind":"nat"}},{"kind":"bool"},{"index":1,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":6,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":4,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"index":2,"kind":"field","value":{"kind":"var","name":1}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"nat"},{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"condition":{"index":1,"kind":"field","value":{"kind":"var","name":0}},"else_branch":{"condition":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":0,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":0,"kind":"adt"},{"kind":"nat"}],"result":{"index":0,"kind":"adt"}},{"index":0,"kind":"adt"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-dose-60/provenance.json b/compiler/rust/rust-std/reasoning-dose-60/provenance.json index 903c98eaf..0d244eadc 100644 --- a/compiler/rust/rust-std/reasoning-dose-60/provenance.json +++ b/compiler/rust/rust-std/reasoning-dose-60/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f96501b3836fc78e84a14d4a3f7123bdfa3032a365236e06263cd7493b1b94f7","src/lib.rs":"d717a3caeb5fa31378975d68db7192958c9beb599c424476f857c3fd164b3e0b"},"name":"reasoning_dose_60_std","profile":"rust-std","program":"94fc260ab569c32e5f07d9b4018587bf3894f17d5f47f026fdadb127ee750c08","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f96501b3836fc78e84a14d4a3f7123bdfa3032a365236e06263cd7493b1b94f7","src/lib.rs":"d717a3caeb5fa31378975d68db7192958c9beb599c424476f857c3fd164b3e0b"},"name":"reasoning_dose_60_std","profile":"rust-std","program":"94fc260ab569c32e5f07d9b4018587bf3894f17d5f47f026fdadb127ee750c08","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-goal/package.json b/compiler/rust/rust-std/reasoning-gnaf-goal/package.json index ddb0a125c..d54dc2823 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-goal/package.json +++ b/compiler/rust/rust-std/reasoning-gnaf-goal/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_goal_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_goal_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-goal/provenance.json b/compiler/rust/rust-std/reasoning-gnaf-goal/provenance.json index 267cabdf1..51676b516 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-goal/provenance.json +++ b/compiler/rust/rust-std/reasoning-gnaf-goal/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7c664b1a44d8b0d82829f8a530bf9f18a59c195086e35dd97e0d8d1db06f6b70","src/lib.rs":"3c9f85f3ec07a4ff1c6a736746141acbd3cc061dfcd1ddbdfdd999d66cae1dd1"},"name":"reasoning_gnaf_goal_std","profile":"rust-std","program":"3f7539345858c86ded3ea323d38024b3deb6a45c6c7de84927959e23bbf92512","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7c664b1a44d8b0d82829f8a530bf9f18a59c195086e35dd97e0d8d1db06f6b70","src/lib.rs":"3c9f85f3ec07a4ff1c6a736746141acbd3cc061dfcd1ddbdfdd999d66cae1dd1"},"name":"reasoning_gnaf_goal_std","profile":"rust-std","program":"3f7539345858c86ded3ea323d38024b3deb6a45c6c7de84927959e23bbf92512","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-priority/package.json b/compiler/rust/rust-std/reasoning-gnaf-priority/package.json index 8c34f7e79..7d0634445 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-priority/package.json +++ b/compiler/rust/rust-std/reasoning-gnaf-priority/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_priority_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_priority_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}]}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-priority/provenance.json b/compiler/rust/rust-std/reasoning-gnaf-priority/provenance.json index e88fda7e1..0e259c178 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-priority/provenance.json +++ b/compiler/rust/rust-std/reasoning-gnaf-priority/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d274b20570b03341619467b141a37178a487d0b5de24733e083f91931360a26f","src/lib.rs":"9d82d8d81f6a7c7d5f9c6afc5a52e35128a33cfd58dcb9b238ef7881e296b376"},"name":"reasoning_gnaf_priority_std","profile":"rust-std","program":"3daf7454a6bd393de7d12ecf49636d2914d09cec5748ae837b7684e00b95fe74","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d274b20570b03341619467b141a37178a487d0b5de24733e083f91931360a26f","src/lib.rs":"9d82d8d81f6a7c7d5f9c6afc5a52e35128a33cfd58dcb9b238ef7881e296b376"},"name":"reasoning_gnaf_priority_std","profile":"rust-std","program":"3daf7454a6bd393de7d12ecf49636d2914d09cec5748ae837b7684e00b95fe74","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-sweep/package.json b/compiler/rust/rust-std/reasoning-gnaf-sweep/package.json index f86f8d96c..5e6489895 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-sweep/package.json +++ b/compiler/rust/rust-std/reasoning-gnaf-sweep/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_sweep_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own","own","own"]}],"name":"reasoning_gnaf_sweep_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}},"parameters":[0,1,2,3,4],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"32"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"256"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"16"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"128"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_not"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"64"}}],"operation":{"kind":"nat_add"}}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-gnaf-sweep/provenance.json b/compiler/rust/rust-std/reasoning-gnaf-sweep/provenance.json index cefcb51be..26669aec3 100644 --- a/compiler/rust/rust-std/reasoning-gnaf-sweep/provenance.json +++ b/compiler/rust/rust-std/reasoning-gnaf-sweep/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cdf1a2e6549bd88950dfe97e645ceb896a5437e8a3bf85fde9fda45caeabd1af","src/lib.rs":"1dd6fa41d8bc7c26bd2829b420e6de6bfd26d017ca394c70cf50d5565469bbc5"},"name":"reasoning_gnaf_sweep_std","profile":"rust-std","program":"ed0eba6159b16bcdf765c6e275fceab30b7c9c1b6470f4a19bb09a92a79e19f4","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cdf1a2e6549bd88950dfe97e645ceb896a5437e8a3bf85fde9fda45caeabd1af","src/lib.rs":"1dd6fa41d8bc7c26bd2829b420e6de6bfd26d017ca394c70cf50d5565469bbc5"},"name":"reasoning_gnaf_sweep_std","profile":"rust-std","program":"ed0eba6159b16bcdf765c6e275fceab30b7c9c1b6470f4a19bb09a92a79e19f4","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-grade-shock/package.json b/compiler/rust/rust-std/reasoning-grade-shock/package.json index 1d7e77bb6..2a18d9419 100644 --- a/compiler/rust/rust-std/reasoning-grade-shock/package.json +++ b/compiler/rust/rust-std/reasoning-grade-shock/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_shock_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_shock_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-grade-shock/provenance.json b/compiler/rust/rust-std/reasoning-grade-shock/provenance.json index 5d1325f5d..5be95765c 100644 --- a/compiler/rust/rust-std/reasoning-grade-shock/provenance.json +++ b/compiler/rust/rust-std/reasoning-grade-shock/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b0ec18565a0061f342e0ddbea1c571e6cdc31b992192b18851da3f63a7f66492","src/lib.rs":"9f0933e50f47ed44513bdb1e5764d9b13c33de1be96385880c939b503a81bc31"},"name":"reasoning_grade_shock_std","profile":"rust-std","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b0ec18565a0061f342e0ddbea1c571e6cdc31b992192b18851da3f63a7f66492","src/lib.rs":"9f0933e50f47ed44513bdb1e5764d9b13c33de1be96385880c939b503a81bc31"},"name":"reasoning_grade_shock_std","profile":"rust-std","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-grade-well/package.json b/compiler/rust/rust-std/reasoning-grade-well/package.json index 7c38a4315..c62098f13 100644 --- a/compiler/rust/rust-std/reasoning-grade-well/package.json +++ b/compiler/rust/rust-std/reasoning-grade-well/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_well_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_grade_well_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":37,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-grade-well/provenance.json b/compiler/rust/rust-std/reasoning-grade-well/provenance.json index ec49bedb5..243710968 100644 --- a/compiler/rust/rust-std/reasoning-grade-well/provenance.json +++ b/compiler/rust/rust-std/reasoning-grade-well/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e5aae7bacd38b43468b7d1aad15d6666cc62a5bed9abc588a425a8938a781e05","src/lib.rs":"9f0933e50f47ed44513bdb1e5764d9b13c33de1be96385880c939b503a81bc31"},"name":"reasoning_grade_well_std","profile":"rust-std","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e5aae7bacd38b43468b7d1aad15d6666cc62a5bed9abc588a425a8938a781e05","src/lib.rs":"9f0933e50f47ed44513bdb1e5764d9b13c33de1be96385880c939b503a81bc31"},"name":"reasoning_grade_well_std","profile":"rust-std","program":"7ff5b1276ef132016ac9da5b0a77c470eccabe50e899ca8c471b5c1d088afd5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-plan-2/package.json b/compiler/rust/rust-std/reasoning-plan-2/package.json index 41a0f8c3a..9061e250c 100644 --- a/compiler/rust/rust-std/reasoning-plan-2/package.json +++ b/compiler/rust/rust-std/reasoning-plan-2/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_plan_2_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[],[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":32,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":25,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_mul"}},{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":0}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":28,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":18,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":9,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":30,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"function":31,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}]},{"body":{"function":29,"kind":"call","operands":[{"captures":[],"function":21,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":2,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"second","value":{"kind":"var","name":7}},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"function":26,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":8}]},"kind":"let","name":9,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"first","value":{"kind":"var","name":7}}],"operation":{"kind":"append"}},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":22,"kind":"call","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"bound":{"function":20,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_plan_2_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[],[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":32,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":25,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_mul"}},{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":0}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":28,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":18,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":9,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":30,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"function":31,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}]},{"body":{"function":29,"kind":"call","operands":[{"captures":[],"function":21,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":2,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"second","value":{"kind":"var","name":7}},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"function":26,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":8}]},"kind":"let","name":9,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"first","value":{"kind":"var","name":7}}],"operation":{"kind":"append"}},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":22,"kind":"call","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"bound":{"function":20,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-plan-2/provenance.json b/compiler/rust/rust-std/reasoning-plan-2/provenance.json index 790a77870..6e10de80b 100644 --- a/compiler/rust/rust-std/reasoning-plan-2/provenance.json +++ b/compiler/rust/rust-std/reasoning-plan-2/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"717568141a6f7d58a1256ffbb9faa063536255f60c354d18318f9fbed31c5606","src/lib.rs":"a7ada95cc9dfe0c7dcf9d2fcac9194236134b82061947cc1cc304af9c454849a"},"name":"reasoning_plan_2_std","profile":"rust-std","program":"ca078dae05ae66f886417b7bbdb424579795ed76385f082a0e889ee35408dff1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"717568141a6f7d58a1256ffbb9faa063536255f60c354d18318f9fbed31c5606","src/lib.rs":"a7ada95cc9dfe0c7dcf9d2fcac9194236134b82061947cc1cc304af9c454849a"},"name":"reasoning_plan_2_std","profile":"rust-std","program":"ca078dae05ae66f886417b7bbdb424579795ed76385f082a0e889ee35408dff1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-plan-5/package.json b/compiler/rust/rust-std/reasoning-plan-5/package.json index 520ff2923..78f7f6e6f 100644 --- a/compiler/rust/rust-std/reasoning-plan-5/package.json +++ b/compiler/rust/rust-std/reasoning-plan-5/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_plan_5_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[],[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":32,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":25,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_mul"}},{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":0}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":28,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":18,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":9,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":30,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"function":31,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}]},{"body":{"function":29,"kind":"call","operands":[{"captures":[],"function":21,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":2,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"second","value":{"kind":"var","name":7}},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"function":26,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":8}]},"kind":"let","name":9,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"first","value":{"kind":"var","name":7}}],"operation":{"kind":"append"}},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":22,"kind":"call","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"bound":{"function":20,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_plan_5_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[],[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":32,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":25,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}}],"operation":{"kind":"nat_mul"}},{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":0}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":11,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":28,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":18,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":9,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":30,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"function":31,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}]},{"body":{"function":29,"kind":"call","operands":[{"captures":[],"function":21,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":2,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"second","value":{"kind":"var","name":7}},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"function":26,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":4,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":9}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":27,"kind":"call","operands":[{"captures":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"function":23,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":8}]},"kind":"let","name":9,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"first","value":{"kind":"var","name":7}}],"operation":{"kind":"append"}},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":22,"kind":"call","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"bound":{"function":20,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"prim","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"index":1,"kind":"adt"}],"result":{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}},{"kind":"pair","left":{"element":{"index":1,"kind":"adt"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":31,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-plan-5/provenance.json b/compiler/rust/rust-std/reasoning-plan-5/provenance.json index 63ed8e6b9..7cbb6e0d8 100644 --- a/compiler/rust/rust-std/reasoning-plan-5/provenance.json +++ b/compiler/rust/rust-std/reasoning-plan-5/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"498a4b1410308f4b1abdf2fee3d1bb543ecf1395f8984caad5891bd5dbeffdcd","src/lib.rs":"a7ada95cc9dfe0c7dcf9d2fcac9194236134b82061947cc1cc304af9c454849a"},"name":"reasoning_plan_5_std","profile":"rust-std","program":"ca078dae05ae66f886417b7bbdb424579795ed76385f082a0e889ee35408dff1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"498a4b1410308f4b1abdf2fee3d1bb543ecf1395f8984caad5891bd5dbeffdcd","src/lib.rs":"a7ada95cc9dfe0c7dcf9d2fcac9194236134b82061947cc1cc304af9c454849a"},"name":"reasoning_plan_5_std","profile":"rust-std","program":"ca078dae05ae66f886417b7bbdb424579795ed76385f082a0e889ee35408dff1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-review-exhausted/package.json b/compiler/rust/rust-std/reasoning-review-exhausted/package.json index a00658c6c..602f98d43 100644 --- a/compiler/rust/rust-std/reasoning-review-exhausted/package.json +++ b/compiler/rust/rust-std/reasoning-review-exhausted/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_exhausted_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_exhausted_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-review-exhausted/provenance.json b/compiler/rust/rust-std/reasoning-review-exhausted/provenance.json index b3f7ba628..7bdcc5762 100644 --- a/compiler/rust/rust-std/reasoning-review-exhausted/provenance.json +++ b/compiler/rust/rust-std/reasoning-review-exhausted/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cb500516998adf5971e40f1d9c52e9238e38648efaa07dcb99191dc723608681","src/lib.rs":"5396dbd5d51335c3ee80994acb616953a93b315895cdee0447c3902e744e9391"},"name":"reasoning_review_exhausted_std","profile":"rust-std","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"cb500516998adf5971e40f1d9c52e9238e38648efaa07dcb99191dc723608681","src/lib.rs":"5396dbd5d51335c3ee80994acb616953a93b315895cdee0447c3902e744e9391"},"name":"reasoning_review_exhausted_std","profile":"rust-std","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-review-rejected/package.json b/compiler/rust/rust-std/reasoning-review-rejected/package.json index 346bd48ae..b227ef9b3 100644 --- a/compiler/rust/rust-std/reasoning-review-rejected/package.json +++ b/compiler/rust/rust-std/reasoning-review-rejected/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_rejected_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_review_rejected_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-review-rejected/provenance.json b/compiler/rust/rust-std/reasoning-review-rejected/provenance.json index 3ca323465..f86932e2b 100644 --- a/compiler/rust/rust-std/reasoning-review-rejected/provenance.json +++ b/compiler/rust/rust-std/reasoning-review-rejected/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"09ad0e8f7a241718b3911348bc5bcfc23e79cc3ae156726eb0ca6c77043ef334","src/lib.rs":"5396dbd5d51335c3ee80994acb616953a93b315895cdee0447c3902e744e9391"},"name":"reasoning_review_rejected_std","profile":"rust-std","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"09ad0e8f7a241718b3911348bc5bcfc23e79cc3ae156726eb0ca6c77043ef334","src/lib.rs":"5396dbd5d51335c3ee80994acb616953a93b315895cdee0447c3902e744e9391"},"name":"reasoning_review_rejected_std","profile":"rust-std","program":"4fbef4ae1d9d00a4f618d0ca2a38865abf9a97c170f9458eb0d583c2182ccb90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-0/package.json b/compiler/rust/rust-std/reasoning-screen-0/package.json index a78d4344a..513d7e856 100644 --- a/compiler/rust/rust-std/reasoning-screen-0/package.json +++ b/compiler/rust/rust-std/reasoning-screen-0/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_0_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_0_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-0/provenance.json b/compiler/rust/rust-std/reasoning-screen-0/provenance.json index 639d86964..e656104b7 100644 --- a/compiler/rust/rust-std/reasoning-screen-0/provenance.json +++ b/compiler/rust/rust-std/reasoning-screen-0/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"51b5d165422c064fbc3b0cc295c64cc620953d945e1a29df58a93c33dd9a5c3c","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_0_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"51b5d165422c064fbc3b0cc295c64cc620953d945e1a29df58a93c33dd9a5c3c","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_0_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-100/package.json b/compiler/rust/rust-std/reasoning-screen-100/package.json index 12a1afef4..51da2068f 100644 --- a/compiler/rust/rust-std/reasoning-screen-100/package.json +++ b/compiler/rust/rust-std/reasoning-screen-100/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_100_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_100_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-100/provenance.json b/compiler/rust/rust-std/reasoning-screen-100/provenance.json index ae39f1043..9ad48bc3d 100644 --- a/compiler/rust/rust-std/reasoning-screen-100/provenance.json +++ b/compiler/rust/rust-std/reasoning-screen-100/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5e417aa06fc7830dce253eb13df2553f44ae0ae4396f8c17cf861614fd430673","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_100_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5e417aa06fc7830dce253eb13df2553f44ae0ae4396f8c17cf861614fd430673","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_100_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-60/package.json b/compiler/rust/rust-std/reasoning-screen-60/package.json index d28474cc5..2747564dd 100644 --- a/compiler/rust/rust-std/reasoning-screen-60/package.json +++ b/compiler/rust/rust-std/reasoning-screen-60/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_60_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_screen_60_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}]]},{"constructors":[[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]},{"constructors":[[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}},{"kind":"bool"},{"index":3,"kind":"adt"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"kind":"second","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_and"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}}},{"kind":"build","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"kind":"build","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"first","value":{"kind":"var","name":1}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}}},"bound":{"function":19,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":15,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"8"}},{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":0,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"condition":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"30"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"50"}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":0}],"operation":{"kind":"nat_le"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}]},{"body":{"function":18,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":11,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}]},"parameters":[0],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":1},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"nat"},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}]},{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0],"result":{"index":2,"kind":"adt"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"body":{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":8},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"index":1,"kind":"adt"}}}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":1}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"prim","operands":[{"kind":"var","name":7}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"function":16,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":3}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"condition":{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"index":5,"kind":"field","value":{"index":3,"kind":"field","value":{"kind":"var","name":1}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"var","name":8}],"operation":{"kind":"length"}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"bound":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"function":13,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":4}],"operation":{"kind":"append"}},"kind":"let","name":7,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"bound":{"function":12,"kind":"call","operands":[{"kind":"var","name":3}]},"kind":"let","name":6,"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":3}}]},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"index":0,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":1,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"length"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":1,"kind":"adt"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":1,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"kind":"nat"}],"result":{"element":{"index":1,"kind":"adt"},"kind":"list"}},{"element":{"index":1,"kind":"adt"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":2,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":2,"kind":"adt"}],"result":{"kind":"option","value":{"index":2,"kind":"adt"}}},{"kind":"nat"},{"index":2,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-screen-60/provenance.json b/compiler/rust/rust-std/reasoning-screen-60/provenance.json index 5b22e0e8e..cbbc8c0dc 100644 --- a/compiler/rust/rust-std/reasoning-screen-60/provenance.json +++ b/compiler/rust/rust-std/reasoning-screen-60/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6b2ba79c93d98fec40d7c38459891c240b44b878f9f72528047529e0215f5b9f","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_60_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6b2ba79c93d98fec40d7c38459891c240b44b878f9f72528047529e0215f5b9f","src/lib.rs":"19bdb3978ae3737d3bf479286a02425b12d2d49c1599b69a56f8fef01b6192c7"},"name":"reasoning_screen_60_std","profile":"rust-std","program":"2c82dd43ba6e271789a7bdc044634f9692c15588ec645405507ced8f905e9760","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-spend-2/package.json b/compiler/rust/rust-std/reasoning-spend-2/package.json index ace150fa3..6b5a9bf6b 100644 --- a/compiler/rust/rust-std/reasoning-spend-2/package.json +++ b/compiler/rust/rust-std/reasoning-spend-2/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_spend_2_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":16,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":18,"kind":"call","operands":[{"captures":[],"function":12,"kind":"closure"},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_add"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"var","name":3}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"option","value":{"index":0,"kind":"adt"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":9,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}}},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2],"body":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"fn","parameters":[{"kind":"option","value":{"index":0,"kind":"adt"}},{"kind":"nat"}],"result":{"kind":"option","value":{"index":0,"kind":"adt"}}},{"kind":"option","value":{"index":0,"kind":"adt"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_spend_2_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"kind":"nat"}]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":16,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":18,"kind":"call","operands":[{"captures":[],"function":12,"kind":"closure"},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}}],"operation":{"kind":"nat_add"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"second","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"var","name":3}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"option","value":{"index":0,"kind":"adt"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":17,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":9,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}}},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2],"body":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"index":0,"kind":"adt"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"index":0,"kind":"adt"}},"types":[{"kind":"fn","parameters":[{"kind":"option","value":{"index":0,"kind":"adt"}},{"kind":"nat"}],"result":{"kind":"option","value":{"index":0,"kind":"adt"}}},{"kind":"option","value":{"index":0,"kind":"adt"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-spend-2/provenance.json b/compiler/rust/rust-std/reasoning-spend-2/provenance.json index b12749315..14a0076b1 100644 --- a/compiler/rust/rust-std/reasoning-spend-2/provenance.json +++ b/compiler/rust/rust-std/reasoning-spend-2/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c2c0345745bacad0251a4e80ba7a892918c1c6a168796097020e4bdeb384462e","src/lib.rs":"6cb861df6eb1109f2978be8097a5f4d0e34aad0afd939536ffc0ac19e986344f"},"name":"reasoning_spend_2_std","profile":"rust-std","program":"17434eb3a9b6f5c3d3c280a02d2c2af7cb3c4cdb5780c3478abb893d9a0915df","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c2c0345745bacad0251a4e80ba7a892918c1c6a168796097020e4bdeb384462e","src/lib.rs":"6cb861df6eb1109f2978be8097a5f4d0e34aad0afd939536ffc0ac19e986344f"},"name":"reasoning_spend_2_std","profile":"rust-std","program":"17434eb3a9b6f5c3d3c280a02d2c2af7cb3c4cdb5780c3478abb893d9a0915df","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-shock/package.json b/compiler/rust/rust-std/reasoning-triage-shock/package.json index 2c170e6f1..69e53e34d 100644 --- a/compiler/rust/rust-std/reasoning-triage-shock/package.json +++ b/compiler/rust/rust-std/reasoning-triage-shock/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_shock_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_shock_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-shock/provenance.json b/compiler/rust/rust-std/reasoning-triage-shock/provenance.json index 2f8788903..660461dfc 100644 --- a/compiler/rust/rust-std/reasoning-triage-shock/provenance.json +++ b/compiler/rust/rust-std/reasoning-triage-shock/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"46d28860996d9df4a3360d03655c6f27c081ec31f6c333a1983f433b055e728d","src/lib.rs":"5948011c40fff786904f62fe0a4097bcdc99c97a436cc265433e3a74f0168db4"},"name":"reasoning_triage_shock_std","profile":"rust-std","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"46d28860996d9df4a3360d03655c6f27c081ec31f6c333a1983f433b055e728d","src/lib.rs":"5948011c40fff786904f62fe0a4097bcdc99c97a436cc265433e3a74f0168db4"},"name":"reasoning_triage_shock_std","profile":"rust-std","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-traced/package.json b/compiler/rust/rust-std/reasoning-triage-traced/package.json index 097b08647..e1cd2e7fc 100644 --- a/compiler/rust/rust-std/reasoning-triage-traced/package.json +++ b/compiler/rust/rust-std/reasoning-triage-traced/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_traced_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":1,"kind":"adt"},{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":3,"kind":"adt"}]]}],"functions":[{"body":{"body":{"body":{"kind":"build","operands":[{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"kind":"cond","then_branch":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"index":1,"kind":"field","value":{"kind":"var","name":2}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"ok"}},{"binders":[4],"body":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"function":39,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":2}}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}}},{"kind":"build","operands":[{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}}]}],"operation":{"kind":"nat_add"}}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"index":4,"kind":"adt"}},"bound":{"function":41,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"function":33,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":4,"kind":"adt"}},"parameters":[0],"result":{"index":4,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":4,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"var","name":1}]},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":4,"kind":"adt"}},"types":[{"index":4,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":7,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":8,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":40,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":37,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":37,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":41,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":4,"kind":"adt"}],"result":{"kind":"option","value":{"index":4,"kind":"adt"}}},{"kind":"nat"},{"index":4,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_traced_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":1,"kind":"adt"},{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":3,"kind":"adt"}]]}],"functions":[{"body":{"body":{"body":{"kind":"build","operands":[{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"kind":"cond","then_branch":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"index":1,"kind":"field","value":{"kind":"var","name":2}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"ok"}},{"binders":[4],"body":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"function":39,"kind":"call","operands":[{"kind":"var","name":0},{"index":0,"kind":"field","value":{"kind":"var","name":2}}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}}}},{"kind":"build","operands":[{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}}]}],"operation":{"kind":"nat_add"}}},{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":2}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"index":4,"kind":"adt"}},"bound":{"function":41,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"pair","left":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"index":2,"kind":"adt"},"kind":"list"}}},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"function":33,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":4,"kind":"adt"}},"parameters":[0],"result":{"index":4,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"index":4,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}},{"index":5,"kind":"field","value":{"index":2,"kind":"field","value":{"kind":"var","name":0}}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":3,"kind":"adt"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":4,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"var","name":1}]},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]},"type":{"kind":"option","value":{"index":4,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":4,"kind":"adt"}},"types":[{"index":4,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":6,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":7,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":8,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":40,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":37,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":37,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":41,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":4,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":4,"kind":"adt"}],"result":{"kind":"option","value":{"index":4,"kind":"adt"}}},{"kind":"nat"},{"index":4,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-traced/provenance.json b/compiler/rust/rust-std/reasoning-triage-traced/provenance.json index 6fa45efc3..0b4d8d5a9 100644 --- a/compiler/rust/rust-std/reasoning-triage-traced/provenance.json +++ b/compiler/rust/rust-std/reasoning-triage-traced/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d9f99faa03f5d85f3668afd131e4913d1dd8f244eae5cff2be1be3e50fd7d819","src/lib.rs":"f8586929a562aa500caab2148af0d1eeb40b7baa9f5e39ac6dae57ce3f43eb8f"},"name":"reasoning_triage_traced_std","profile":"rust-std","program":"e33ee5ee49170ed518748c5476e407b9437a41cdd26f5421125ecfa55e152ac3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d9f99faa03f5d85f3668afd131e4913d1dd8f244eae5cff2be1be3e50fd7d819","src/lib.rs":"f8586929a562aa500caab2148af0d1eeb40b7baa9f5e39ac6dae57ce3f43eb8f"},"name":"reasoning_triage_traced_std","profile":"rust-std","program":"e33ee5ee49170ed518748c5476e407b9437a41cdd26f5421125ecfa55e152ac3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-well/package.json b/compiler/rust/rust-std/reasoning-triage-well/package.json index e5dfec6cc..925e62ff4 100644 --- a/compiler/rust/rust-std/reasoning-triage-well/package.json +++ b/compiler/rust/rust-std/reasoning-triage-well/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_well_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"reasoning_triage_well_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"index":0,"kind":"adt"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[],[],[],[],[],[],[],[]]}],"functions":[{"body":{"body":{"condition":{"kind":"second","value":{"kind":"var","name":1}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]}},"bound":{"function":38,"kind":"call","operands":[{"captures":[],"function":33,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"11"}},{"function":30,"kind":"call","operands":[{"kind":"var","name":0}]}]},"kind":"let","name":1,"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"380"}},{"index":0,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}},{"index":1,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"12"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"90"}}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":1,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":2,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":3,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"function":4,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"index":0,"kind":"field","value":{"kind":"var","name":0}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"function":5,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}},{"index":3,"kind":"field","value":{"kind":"var","name":0}},{"index":4,"kind":"field","value":{"kind":"var","name":0}},{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"index":6,"kind":"field","value":{"kind":"var","name":0}},{"index":7,"kind":"field","value":{"kind":"var","name":0}},{"kind":"prim","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":14,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":15,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":17,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0],"result":{"index":1,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":7,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":6,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":5,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":4,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":3,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":1,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"index":2,"kind":"adt"}}}},"parameters":[0],"result":{"kind":"option","value":{"index":2,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[],"body":{"function":23,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":2,"kind":"adt"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":3,"kind":"adt"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":4,"kind":"adt"}},{"binders":[],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":5,"kind":"adt"}},{"binders":[],"body":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":6,"kind":"adt"}},{"binders":[],"body":{"function":29,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"constructor":7,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0,1],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":32,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":31,"kind":"call","operands":[{"kind":"var","name":0}]},"type":{"kind":"option","value":{"index":1,"kind":"adt"}}},"parameters":[0],"result":{"kind":"option","value":{"index":1,"kind":"adt"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"kind":"build","operands":[{"index":8,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"none"}},{"binders":[2],"body":{"body":{"condition":{"kind":"var","name":3},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"function":37,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"kind":"let","name":3,"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"ok"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[3],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"error"},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":34,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}}},"parameters":[0,1],"result":{"error":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}},"kind":"result","ok":{"kind":"nat"}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"index":5,"kind":"field","value":{"kind":"var","name":0}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_and"}}],"operation":{"kind":"bool_not"}}],"operation":{"kind":"bool_or"}}],"operation":{"kind":"bool_and"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"}],"result":{"kind":"option","value":{"index":1,"kind":"adt"}}},{"kind":"nat"},{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/reasoning-triage-well/provenance.json b/compiler/rust/rust-std/reasoning-triage-well/provenance.json index 01d0fbf28..55321191d 100644 --- a/compiler/rust/rust-std/reasoning-triage-well/provenance.json +++ b/compiler/rust/rust-std/reasoning-triage-well/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aceb80958d7147805d89b25b06e0deeabff1948a86f4f7653fa7305263dd17f7","src/lib.rs":"5948011c40fff786904f62fe0a4097bcdc99c97a436cc265433e3a74f0168db4"},"name":"reasoning_triage_well_std","profile":"rust-std","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aceb80958d7147805d89b25b06e0deeabff1948a86f4f7653fa7305263dd17f7","src/lib.rs":"5948011c40fff786904f62fe0a4097bcdc99c97a436cc265433e3a74f0168db4"},"name":"reasoning_triage_well_std","profile":"rust-std","program":"754fca76975093fa27b62f115ad8a931069e28b657cc9d03073a6bf862ffb02e","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/record-fields/package.json b/compiler/rust/rust-std/record-fields/package.json index ef7da003a..bd49cf1dc 100644 --- a/compiler/rust/rust-std/record-fields/package.json +++ b/compiler/rust/rust-std/record-fields/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"record_fields_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"record_fields_std","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"operation":{"kind":"nat_sub"}},{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":0}},{"index":2,"kind":"field","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/record-fields/provenance.json b/compiler/rust/rust-std/record-fields/provenance.json index 4ca7e4cc8..77adac5d4 100644 --- a/compiler/rust/rust-std/record-fields/provenance.json +++ b/compiler/rust/rust-std/record-fields/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"657125c6db500bcf591eb9b5898a4fb6aa8b9f416dd2191d51e69c9d67e6a88c","src/lib.rs":"c13b5754cdf4860ffbb861d0ba6f54acb22dc4d1a086e8ac5750e4297bcb974e"},"name":"record_fields_std","profile":"rust-std","program":"526bb181b433435ecf3b9116937f342406bd8db3d26cc26b870d03e7f3c11ca9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"657125c6db500bcf591eb9b5898a4fb6aa8b9f416dd2191d51e69c9d67e6a88c","src/lib.rs":"c13b5754cdf4860ffbb861d0ba6f54acb22dc4d1a086e8ac5750e4297bcb974e"},"name":"record_fields_std","profile":"rust-std","program":"526bb181b433435ecf3b9116937f342406bd8db3d26cc26b870d03e7f3c11ca9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-contains-absent/package.json b/compiler/rust/rust-std/set-contains-absent/package.json index f87cd470a..5500278e2 100644 --- a/compiler/rust/rust-std/set-contains-absent/package.json +++ b/compiler/rust/rust-std/set-contains-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_contains_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_contains_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-contains-absent/provenance.json b/compiler/rust/rust-std/set-contains-absent/provenance.json index 668347cc1..ad6d48b5e 100644 --- a/compiler/rust/rust-std/set-contains-absent/provenance.json +++ b/compiler/rust/rust-std/set-contains-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d0390ea8a751a564e893b86883b7c4ded0bdcdf0fd444111d2015750ab6c0fe0","src/lib.rs":"f8ded3662c8756234a9fe0ad3f725becbbfb3945e38cec3088dcafac76bd44bd"},"name":"set_contains_absent_std","profile":"rust-std","program":"2830740fb7f083476ef600b571be85a9e1ad2a7d7a2f0965d2ff4d8a184cd330","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d0390ea8a751a564e893b86883b7c4ded0bdcdf0fd444111d2015750ab6c0fe0","src/lib.rs":"f8ded3662c8756234a9fe0ad3f725becbbfb3945e38cec3088dcafac76bd44bd"},"name":"set_contains_absent_std","profile":"rust-std","program":"2830740fb7f083476ef600b571be85a9e1ad2a7d7a2f0965d2ff4d8a184cd330","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-contains/package.json b/compiler/rust/rust-std/set-contains/package.json index 5b775006f..2ddb68079 100644 --- a/compiler/rust/rust-std/set-contains/package.json +++ b/compiler/rust/rust-std/set-contains/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_contains_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_contains_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-contains/provenance.json b/compiler/rust/rust-std/set-contains/provenance.json index 38c57f5f6..4fbb45c4d 100644 --- a/compiler/rust/rust-std/set-contains/provenance.json +++ b/compiler/rust/rust-std/set-contains/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"91a6d7687599dc3bd4c1a1de6489516564fc670387c3094da506db6305395617","src/lib.rs":"f8ded3662c8756234a9fe0ad3f725becbbfb3945e38cec3088dcafac76bd44bd"},"name":"set_contains_std","profile":"rust-std","program":"2830740fb7f083476ef600b571be85a9e1ad2a7d7a2f0965d2ff4d8a184cd330","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"91a6d7687599dc3bd4c1a1de6489516564fc670387c3094da506db6305395617","src/lib.rs":"f8ded3662c8756234a9fe0ad3f725becbbfb3945e38cec3088dcafac76bd44bd"},"name":"set_contains_std","profile":"rust-std","program":"2830740fb7f083476ef600b571be85a9e1ad2a7d7a2f0965d2ff4d8a184cd330","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-difference/package.json b/compiler/rust/rust-std/set-difference/package.json index 33df24a5a..7457db72c 100644 --- a/compiler/rust/rust-std/set-difference/package.json +++ b/compiler/rust/rust-std/set-difference/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_difference_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_difference_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-difference/provenance.json b/compiler/rust/rust-std/set-difference/provenance.json index 38b3b885e..f9e48e8b4 100644 --- a/compiler/rust/rust-std/set-difference/provenance.json +++ b/compiler/rust/rust-std/set-difference/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7d66fd60ef4599f30ed46df653974df13d29815852f0762ea225e9b214406c46","src/lib.rs":"03edafd16af85fd58f68d2608ad2a29dfbfc75e32d055eadcba43c1c143f6985"},"name":"set_difference_std","profile":"rust-std","program":"e4eedda413cfe9163e193858d2055a14ab25e3243d13a52063f2db62b9d0e044","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7d66fd60ef4599f30ed46df653974df13d29815852f0762ea225e9b214406c46","src/lib.rs":"03edafd16af85fd58f68d2608ad2a29dfbfc75e32d055eadcba43c1c143f6985"},"name":"set_difference_std","profile":"rust-std","program":"e4eedda413cfe9163e193858d2055a14ab25e3243d13a52063f2db62b9d0e044","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-fold/package.json b/compiler/rust/rust-std/set-fold/package.json index 530e4efa7..e687ba191 100644 --- a/compiler/rust/rust-std/set-fold/package.json +++ b/compiler/rust/rust-std/set-fold/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"set_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"set_fold_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":2,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-fold/provenance.json b/compiler/rust/rust-std/set-fold/provenance.json index e493605e7..749113a55 100644 --- a/compiler/rust/rust-std/set-fold/provenance.json +++ b/compiler/rust/rust-std/set-fold/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7473aca13da8e0e6cf970bffae5f972798f7cbe74fd83f4a572aa2f9e268c43e","src/lib.rs":"9b1f7c8d2991d0f182a4a81a590dddeb5c3d58c01fb799f067b87f9cf3340b21"},"name":"set_fold_std","profile":"rust-std","program":"9ec1f516d6a7a34284bd32ea60ad534e79b8a3051e015182f82e02663f083863","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7473aca13da8e0e6cf970bffae5f972798f7cbe74fd83f4a572aa2f9e268c43e","src/lib.rs":"9b1f7c8d2991d0f182a4a81a590dddeb5c3d58c01fb799f067b87f9cf3340b21"},"name":"set_fold_std","profile":"rust-std","program":"9ec1f516d6a7a34284bd32ea60ad534e79b8a3051e015182f82e02663f083863","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-bool/package.json b/compiler/rust/rust-std/set-insert-bool/package.json index e6b559dc2..a62996fb5 100644 --- a/compiler/rust/rust-std/set-insert-bool/package.json +++ b/compiler/rust/rust-std/set-insert-bool/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_bool_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"bool"},"kind":"list"},{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"bool"},"kind":"list"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_bool_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"bool"},"kind":"list"},{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"bool"},"kind":"list"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-bool/provenance.json b/compiler/rust/rust-std/set-insert-bool/provenance.json index 41d5f47fa..8a80454fc 100644 --- a/compiler/rust/rust-std/set-insert-bool/provenance.json +++ b/compiler/rust/rust-std/set-insert-bool/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ac8196157ba2b724656ab338c86de33b1cfeb222d4450ad25852d973d8cdaa10","src/lib.rs":"a4df278260c79a1680f80dabbe1adc4c5e7b9088731deb27061f99b82f83b5ef"},"name":"set_insert_bool_std","profile":"rust-std","program":"3b7f3f374ccb0b9f3a3ccf2b65f878f5f3a3d928757a7f54116edd2d6fc09cd6","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ac8196157ba2b724656ab338c86de33b1cfeb222d4450ad25852d973d8cdaa10","src/lib.rs":"a4df278260c79a1680f80dabbe1adc4c5e7b9088731deb27061f99b82f83b5ef"},"name":"set_insert_bool_std","profile":"rust-std","program":"3b7f3f374ccb0b9f3a3ccf2b65f878f5f3a3d928757a7f54116edd2d6fc09cd6","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-int/package.json b/compiler/rust/rust-std/set-insert-int/package.json index 2e400893d..53b4d9319 100644 --- a/compiler/rust/rust-std/set-insert-int/package.json +++ b/compiler/rust/rust-std/set-insert-int/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_int_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"int"},"kind":"list"},"types":[{"element":{"kind":"int"},"kind":"list"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"int"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"int"},"kind":"list"},"types":[{"element":{"kind":"int"},"kind":"list"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_int_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"int"},"kind":"list"},"types":[{"element":{"kind":"int"},"kind":"list"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"int"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"int"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"int"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"int"},"kind":"list"},"types":[{"element":{"kind":"int"},"kind":"list"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-int/provenance.json b/compiler/rust/rust-std/set-insert-int/provenance.json index 739924dd5..66f1f19c7 100644 --- a/compiler/rust/rust-std/set-insert-int/provenance.json +++ b/compiler/rust/rust-std/set-insert-int/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"51f8f5cfc5ddb86c8cf62f6db2e3c95a011e50de63a1d4b070be9a3d5e3eb38f","src/lib.rs":"427014d899e9c4cd5a84a5e8d3d7fae012881d9674268393f91ef70499613878"},"name":"set_insert_int_std","profile":"rust-std","program":"210b77cf3849c034b591a9dba6ebb3b71f0bf5385789667cfdf8a1a6cf96a322","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"51f8f5cfc5ddb86c8cf62f6db2e3c95a011e50de63a1d4b070be9a3d5e3eb38f","src/lib.rs":"427014d899e9c4cd5a84a5e8d3d7fae012881d9674268393f91ef70499613878"},"name":"set_insert_int_std","profile":"rust-std","program":"210b77cf3849c034b591a9dba6ebb3b71f0bf5385789667cfdf8a1a6cf96a322","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-int8/package.json b/compiler/rust/rust-std/set-insert-int8/package.json index 0fc463c3a..0f623702a 100644 --- a/compiler/rust/rust-std/set-insert-int8/package.json +++ b/compiler/rust/rust-std/set-insert-int8/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_int8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"types":[{"element":{"kind":"fixed","width":"i8"},"kind":"list"},{"kind":"fixed","width":"i8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"types":[{"element":{"kind":"fixed","width":"i8"},"kind":"list"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_int8_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"types":[{"element":{"kind":"fixed","width":"i8"},"kind":"list"},{"kind":"fixed","width":"i8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"fixed","width":"i8"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"fixed","width":"i8"},"kind":"list"},"types":[{"element":{"kind":"fixed","width":"i8"},"kind":"list"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-int8/provenance.json b/compiler/rust/rust-std/set-insert-int8/provenance.json index 2c41bb8fb..e46280794 100644 --- a/compiler/rust/rust-std/set-insert-int8/provenance.json +++ b/compiler/rust/rust-std/set-insert-int8/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a0e7c7dc27fc08ddf2f3f1e6896e08bf274fe21d581bef3bd53a99e40ca3cf76","src/lib.rs":"44fb9adfeb185dd26db4416f564615751a1d03e9b24901e70cfbd5913a36c81c"},"name":"set_insert_int8_std","profile":"rust-std","program":"9babee8751d6e4795ac73b01fde4a598f1b1bca03d612fd7f206fb0b17c02165","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a0e7c7dc27fc08ddf2f3f1e6896e08bf274fe21d581bef3bd53a99e40ca3cf76","src/lib.rs":"44fb9adfeb185dd26db4416f564615751a1d03e9b24901e70cfbd5913a36c81c"},"name":"set_insert_int8_std","profile":"rust-std","program":"9babee8751d6e4795ac73b01fde4a598f1b1bca03d612fd7f206fb0b17c02165","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-nat/package.json b/compiler/rust/rust-std/set-insert-nat/package.json index 00ba1b55f..8f9ec4b3e 100644 --- a/compiler/rust/rust-std/set-insert-nat/package.json +++ b/compiler/rust/rust-std/set-insert-nat/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_nat_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_nat_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-nat/provenance.json b/compiler/rust/rust-std/set-insert-nat/provenance.json index f17f1db5e..13564369b 100644 --- a/compiler/rust/rust-std/set-insert-nat/provenance.json +++ b/compiler/rust/rust-std/set-insert-nat/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c1627f7f40f8302b3c95611ae71074d87c05b01f3f18d9ae11f2fb07ff3afe02","src/lib.rs":"e2c636a38f005c91b3d6b5884726656520ef2cb793265251d7812cadadae81c6"},"name":"set_insert_nat_std","profile":"rust-std","program":"e29f1fa97756e738282778c32d52b6bb6a525fcc19254de13baa4383e13a9cf3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c1627f7f40f8302b3c95611ae71074d87c05b01f3f18d9ae11f2fb07ff3afe02","src/lib.rs":"e2c636a38f005c91b3d6b5884726656520ef2cb793265251d7812cadadae81c6"},"name":"set_insert_nat_std","profile":"rust-std","program":"e29f1fa97756e738282778c32d52b6bb6a525fcc19254de13baa4383e13a9cf3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-product/package.json b/compiler/rust/rust-std/set-insert-product/package.json index be69b0dc0..0a581f1f5 100644 --- a/compiler/rust/rust-std/set-insert-product/package.json +++ b/compiler/rust/rust-std/set-insert-product/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_product_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_product_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-product/provenance.json b/compiler/rust/rust-std/set-insert-product/provenance.json index d8d859bd1..0500294a4 100644 --- a/compiler/rust/rust-std/set-insert-product/provenance.json +++ b/compiler/rust/rust-std/set-insert-product/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"dc9df9cc09a1c8992c9f97f34533b23c85d1bf109850fa406f140a46c25016e1","src/lib.rs":"5dba2f1f61e0e0fb48674da270e63250eee92027c5005f9a0bc851c1246f420f"},"name":"set_insert_product_std","profile":"rust-std","program":"869f8307350a0a879811d02d90671307c266023d05b322a1aea0b80156307fe3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"dc9df9cc09a1c8992c9f97f34533b23c85d1bf109850fa406f140a46c25016e1","src/lib.rs":"5dba2f1f61e0e0fb48674da270e63250eee92027c5005f9a0bc851c1246f420f"},"name":"set_insert_product_std","profile":"rust-std","program":"869f8307350a0a879811d02d90671307c266023d05b322a1aea0b80156307fe3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-string/package.json b/compiler/rust/rust-std/set-insert-string/package.json index a7b3ef745..9de01a841 100644 --- a/compiler/rust/rust-std/set-insert-string/package.json +++ b/compiler/rust/rust-std/set-insert-string/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_string_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_insert_string_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-insert-string/provenance.json b/compiler/rust/rust-std/set-insert-string/provenance.json index 3f009c9a7..d107864e8 100644 --- a/compiler/rust/rust-std/set-insert-string/provenance.json +++ b/compiler/rust/rust-std/set-insert-string/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e04bbe8317dd705fbdeed47dc59087473da9a1cc6ce512f00cda702a57f037a0","src/lib.rs":"a3045920e4eb0b27999ce5ddc535a1bb8f20764e381c2623e2486090841cfa2a"},"name":"set_insert_string_std","profile":"rust-std","program":"2aaa06fbba9d8f784ebbaa8cc892760f0dcd8c9ee30a7b117aa2c2894f1fe01a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e04bbe8317dd705fbdeed47dc59087473da9a1cc6ce512f00cda702a57f037a0","src/lib.rs":"a3045920e4eb0b27999ce5ddc535a1bb8f20764e381c2623e2486090841cfa2a"},"name":"set_insert_string_std","profile":"rust-std","program":"2aaa06fbba9d8f784ebbaa8cc892760f0dcd8c9ee30a7b117aa2c2894f1fe01a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-intersection/package.json b/compiler/rust/rust-std/set-intersection/package.json index 90497d4f0..8847804ec 100644 --- a/compiler/rust/rust-std/set-intersection/package.json +++ b/compiler/rust/rust-std/set-intersection/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_intersection_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_intersection_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-intersection/provenance.json b/compiler/rust/rust-std/set-intersection/provenance.json index 149d48a4e..f2596bc5b 100644 --- a/compiler/rust/rust-std/set-intersection/provenance.json +++ b/compiler/rust/rust-std/set-intersection/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"065c99ac2d8e445f9c7d1e757ed1b8d310d62b5dae4591b4f1606d9f696d24a9","src/lib.rs":"a3201ca47c4a09f97a962f7917317536bd4d08027603dfe9fbad12ceb89c0bca"},"name":"set_intersection_std","profile":"rust-std","program":"75c582aab0f65628af4cbdb8726df1c63bb3f09de1c011a8977a1cdddb717930","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"065c99ac2d8e445f9c7d1e757ed1b8d310d62b5dae4591b4f1606d9f696d24a9","src/lib.rs":"a3201ca47c4a09f97a962f7917317536bd4d08027603dfe9fbad12ceb89c0bca"},"name":"set_intersection_std","profile":"rust-std","program":"75c582aab0f65628af4cbdb8726df1c63bb3f09de1c011a8977a1cdddb717930","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-remove-absent/package.json b/compiler/rust/rust-std/set-remove-absent/package.json index 5fd5285cf..861c35cc4 100644 --- a/compiler/rust/rust-std/set-remove-absent/package.json +++ b/compiler/rust/rust-std/set-remove-absent/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_remove_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_remove_absent_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-remove-absent/provenance.json b/compiler/rust/rust-std/set-remove-absent/provenance.json index 4ab66af55..6ba533f77 100644 --- a/compiler/rust/rust-std/set-remove-absent/provenance.json +++ b/compiler/rust/rust-std/set-remove-absent/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ed7b29efadc01b3250e6b8792579e99adb13ee7cca750934476eb73393f3f8dc","src/lib.rs":"67eb791bec07c8a95e727cba4f72d33409c1702f5306ad028de150b6a89b12eb"},"name":"set_remove_absent_std","profile":"rust-std","program":"9f8b76594bb07bf979cb966167884a9bb89ae977401c0fbb9457a939a51a3880","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ed7b29efadc01b3250e6b8792579e99adb13ee7cca750934476eb73393f3f8dc","src/lib.rs":"67eb791bec07c8a95e727cba4f72d33409c1702f5306ad028de150b6a89b12eb"},"name":"set_remove_absent_std","profile":"rust-std","program":"9f8b76594bb07bf979cb966167884a9bb89ae977401c0fbb9457a939a51a3880","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-remove/package.json b/compiler/rust/rust-std/set-remove/package.json index a5d5e6468..a2840e6df 100644 --- a/compiler/rust/rust-std/set-remove/package.json +++ b/compiler/rust/rust-std/set-remove/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_remove_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_remove_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-remove/provenance.json b/compiler/rust/rust-std/set-remove/provenance.json index 6805f67fa..b414d6974 100644 --- a/compiler/rust/rust-std/set-remove/provenance.json +++ b/compiler/rust/rust-std/set-remove/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4b2810bd671579e13c1912c6134046c7ae1f1f48369e8fc16b333d503b0f6ced","src/lib.rs":"67eb791bec07c8a95e727cba4f72d33409c1702f5306ad028de150b6a89b12eb"},"name":"set_remove_std","profile":"rust-std","program":"9f8b76594bb07bf979cb966167884a9bb89ae977401c0fbb9457a939a51a3880","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"4b2810bd671579e13c1912c6134046c7ae1f1f48369e8fc16b333d503b0f6ced","src/lib.rs":"67eb791bec07c8a95e727cba4f72d33409c1702f5306ad028de150b6a89b12eb"},"name":"set_remove_std","profile":"rust-std","program":"9f8b76594bb07bf979cb966167884a9bb89ae977401c0fbb9457a939a51a3880","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-union/package.json b/compiler/rust/rust-std/set-union/package.json index d2e2bb1c7..a2f2b170e 100644 --- a/compiler/rust/rust-std/set-union/package.json +++ b/compiler/rust/rust-std/set-union/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_union_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":1,"kind":"call","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"set_union_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":1,"kind":"call","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/set-union/provenance.json b/compiler/rust/rust-std/set-union/provenance.json index b6ed1f9a2..e42f4f4fd 100644 --- a/compiler/rust/rust-std/set-union/provenance.json +++ b/compiler/rust/rust-std/set-union/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c65da910246da08808f2da2155dd2c328b5ce0961cae63e65d8b98e13b0eb202","src/lib.rs":"4e2d3e13b2cb15205dfc0ed8e9676606d1faa4addcef5672ea36348b502c34a8"},"name":"set_union_std","profile":"rust-std","program":"b7c250f72618139aea007f0241c6e91525523c5710484f1c76b89d9e77090a90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c65da910246da08808f2da2155dd2c328b5ce0961cae63e65d8b98e13b0eb202","src/lib.rs":"4e2d3e13b2cb15205dfc0ed8e9676606d1faa4addcef5672ea36348b502c34a8"},"name":"set_union_std","profile":"rust-std","program":"b7c250f72618139aea007f0241c6e91525523c5710484f1c76b89d9e77090a90","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/split-and-join/package.json b/compiler/rust/rust-std/split-and-join/package.json index ea3de85ac..9a25a9d4e 100644 --- a/compiler/rust/rust-std/split-and-join/package.json +++ b/compiler/rust/rust-std/split-and-join/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"split_and_join_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b,,c"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":","}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"10"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"10"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b,c"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":","}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"2"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aaa"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aa"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ababcab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"abc"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aabaab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ab"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":";"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}},{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"x"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"--"}}],"operation":{"kind":"join"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},"right":{"kind":"string"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},"right":{"kind":"string"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":[]}],"name":"split_and_join_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b,,c"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":","}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"10"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"10"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a,b,c"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":","}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"2"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aaa"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aa"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ababcab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"abc"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"aabaab"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"ab"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"5"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":";"}},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"1"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}},{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"x"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":""}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"z"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"--"}}],"operation":{"kind":"join"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},"right":{"kind":"string"}}},"parameters":[],"result":{"kind":"pair","left":{"element":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},"right":{"kind":"string"}},"types":[]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/split-and-join/provenance.json b/compiler/rust/rust-std/split-and-join/provenance.json index 4338417e0..a621b1045 100644 --- a/compiler/rust/rust-std/split-and-join/provenance.json +++ b/compiler/rust/rust-std/split-and-join/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d200d2a2d485f56f7a86aa2fa75772148915872ae02fb849cc3525c62ee3fc37","src/lib.rs":"90446edf1600486dff6670082ece42ce4650c8c52d03785de8c929e17553db22"},"name":"split_and_join_std","profile":"rust-std","program":"982ffd950ccdcc64baecacf59f92f2b927b0ed9924aab15840d15e590abf8f65","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d200d2a2d485f56f7a86aa2fa75772148915872ae02fb849cc3525c62ee3fc37","src/lib.rs":"90446edf1600486dff6670082ece42ce4650c8c52d03785de8c929e17553db22"},"name":"split_and_join_std","profile":"rust-std","program":"982ffd950ccdcc64baecacf59f92f2b927b0ed9924aab15840d15e590abf8f65","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/string-escapes/package.json b/compiler/rust/rust-std/string-escapes/package.json index 68a62f254..729b33cae 100644 --- a/compiler/rust/rust-std/string-escapes/package.json +++ b/compiler/rust/rust-std/string-escapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"string_escapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"quote\" backslash\\ newline\n tab\t nul\u0000 é x́ ☃ 😀"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"quote\" backslash\\ newline\n tab\t nul\u0000 é x́ ☃ 😀"}}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"string_escapes_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"quote\" backslash\\ newline\n tab\t nul\u0000 é x́ ☃ 😀"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"quote\" backslash\\ newline\n tab\t nul\u0000 é x́ ☃ 😀"}}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/string-escapes/provenance.json b/compiler/rust/rust-std/string-escapes/provenance.json index 265878d0e..001e9ef2f 100644 --- a/compiler/rust/rust-std/string-escapes/provenance.json +++ b/compiler/rust/rust-std/string-escapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"351089a11ce92eae6cbc7f2ce1779fecb816df12c52b7c764e90e850474d6c63","src/lib.rs":"0850367b9b7bf6cb08df1fc745ac222d811cf02e7eda08ff655975faded885d8"},"name":"string_escapes_std","profile":"rust-std","program":"9b460d74ab6318d4fa2802d576ba50f580c272d87a100c66e6f85da294374ba9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"351089a11ce92eae6cbc7f2ce1779fecb816df12c52b7c764e90e850474d6c63","src/lib.rs":"0850367b9b7bf6cb08df1fc745ac222d811cf02e7eda08ff655975faded885d8"},"name":"string_escapes_std","profile":"rust-std","program":"9b460d74ab6318d4fa2802d576ba50f580c272d87a100c66e6f85da294374ba9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/sum-to-exhausted/package.json b/compiler/rust/rust-std/sum-to-exhausted/package.json index f63db23ff..f41821612 100644 --- a/compiler/rust/rust-std/sum-to-exhausted/package.json +++ b/compiler/rust/rust-std/sum-to-exhausted/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_exhausted_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_exhausted_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/sum-to-exhausted/provenance.json b/compiler/rust/rust-std/sum-to-exhausted/provenance.json index 449a214f0..8ba13e28d 100644 --- a/compiler/rust/rust-std/sum-to-exhausted/provenance.json +++ b/compiler/rust/rust-std/sum-to-exhausted/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e78d34d4b838463c88bb11d83eefe033510ab268fe40522ef6b14aaa96117b67","src/lib.rs":"0a13b867605105995fa9a094147359caa58edba2102dbf7b05af7d3db6d7c9a7"},"name":"sum_to_exhausted_std","profile":"rust-std","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e78d34d4b838463c88bb11d83eefe033510ab268fe40522ef6b14aaa96117b67","src/lib.rs":"0a13b867605105995fa9a094147359caa58edba2102dbf7b05af7d3db6d7c9a7"},"name":"sum_to_exhausted_std","profile":"rust-std","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/sum-to/package.json b/compiler/rust/rust-std/sum-to/package.json index 1d0a45e67..beb0108b2 100644 --- a/compiler/rust/rust-std/sum-to/package.json +++ b/compiler/rust/rust-std/sum-to/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_to_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"succ"},"type":{"kind":"nat"}},{"function":0,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/sum-to/provenance.json b/compiler/rust/rust-std/sum-to/provenance.json index 17cd93b68..f8687ef6a 100644 --- a/compiler/rust/rust-std/sum-to/provenance.json +++ b/compiler/rust/rust-std/sum-to/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1e23e50d35294a571590ad01935ab2630558839c3c27048800075f7864aa6a95","src/lib.rs":"0a13b867605105995fa9a094147359caa58edba2102dbf7b05af7d3db6d7c9a7"},"name":"sum_to_std","profile":"rust-std","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"1e23e50d35294a571590ad01935ab2630558839c3c27048800075f7864aa6a95","src/lib.rs":"0a13b867605105995fa9a094147359caa58edba2102dbf7b05af7d3db6d7c9a7"},"name":"sum_to_std","profile":"rust-std","program":"0b5d1623110dd3c47e6d54ff536aea2157c78593eaae53a9752197a171fdc79a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/unit-closures/package.json b/compiler/rust/rust-std/unit-closures/package.json index 732e3fafd..314e8f2e6 100644 --- a/compiler/rust/rust-std/unit-closures/package.json +++ b/compiler/rust/rust-std/unit-closures/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"unit_closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"unit"}},{"kind":"nat"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"unit_closures_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":1,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"unit"}},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"unit"}}}},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"kind":"let","name":1,"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"unit"}},{"kind":"nat"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/unit-closures/provenance.json b/compiler/rust/rust-std/unit-closures/provenance.json index 22e4c9005..fc2f7d459 100644 --- a/compiler/rust/rust-std/unit-closures/provenance.json +++ b/compiler/rust/rust-std/unit-closures/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"faf953f919550ce28fe52f8222706cce910b60edf6a11f96f8f762743109191f","src/lib.rs":"020561b609c98bcdd3cd49b4473a6d3aa021cd9dc8d3e6f1fa8854d233583917"},"name":"unit_closures_std","profile":"rust-std","program":"e2f55254e66e933625b9a18c2414242a0f3a55dccef58b663673c4027a619c34","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"faf953f919550ce28fe52f8222706cce910b60edf6a11f96f8f762743109191f","src/lib.rs":"020561b609c98bcdd3cd49b4473a6d3aa021cd9dc8d3e6f1fa8854d233583917"},"name":"unit_closures_std","profile":"rust-std","program":"e2f55254e66e933625b9a18c2414242a0f3a55dccef58b663673c4027a619c34","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/unit-values/package.json b/compiler/rust/rust-std/unit-values/package.json index ca9cf229f..2fbf6859a 100644 --- a/compiler/rust/rust-std/unit-values/package.json +++ b/compiler/rust/rust-std/unit-values/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"unit_values_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}}},"bound":{"function":5,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}}]},"kind":"let","name":4,"type":{"kind":"unit"}},"bound":{"function":4,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":3,"type":{"kind":"unit"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":2,"type":{"kind":"unit"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"unit"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}]}}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"unit_values_std","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"unit"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}}},"bound":{"function":5,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"9"}}],"operation":{"kind":"nat_lt"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}}]},"kind":"let","name":4,"type":{"kind":"unit"}},"bound":{"function":4,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":3,"type":{"kind":"unit"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":2,"type":{"kind":"unit"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"unit"},"right":{"kind":"option","value":{"kind":"unit"}}},"types":[{"kind":"unit"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"unit"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"unit"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"unit"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"body":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}},"parameters":[0],"result":{"kind":"unit"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"var","name":0},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"condition":{"kind":"var","name":1},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}},"kind":"cond","then_branch":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}]}}},"parameters":[0,1],"result":{"kind":"unit"},"types":[{"kind":"bool"},{"kind":"bool"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/unit-values/provenance.json b/compiler/rust/rust-std/unit-values/provenance.json index 576a44334..1a9997a6f 100644 --- a/compiler/rust/rust-std/unit-values/provenance.json +++ b/compiler/rust/rust-std/unit-values/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8045da83d6b2fb2030e227d9f791ff98b6e68266b4557c08ff33a8e204025f14","src/lib.rs":"ad13289bec0890225a90bdacdef0305b22052f11c27aa4b3af47b12ed83967b1"},"name":"unit_values_std","profile":"rust-std","program":"da46c33882a69c2a5bed667c6e026399692e7ebc318523c341cef90e9257d9ea","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8045da83d6b2fb2030e227d9f791ff98b6e68266b4557c08ff33a8e204025f14","src/lib.rs":"ad13289bec0890225a90bdacdef0305b22052f11c27aa4b3af47b12ed83967b1"},"name":"unit_values_std","profile":"rust-std","program":"da46c33882a69c2a5bed667c6e026399692e7ebc318523c341cef90e9257d9ea","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/wide-shapes/package.json b/compiler/rust/rust-std/wide-shapes/package.json index 81dfb4dc3..1cf934caa 100644 --- a/compiler/rust/rust-std/wide-shapes/package.json +++ b/compiler/rust/rust-std/wide-shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"wide_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":7},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2,3,4,5,6,7],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"wide_shapes_std","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"4"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"6"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"types":[{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":7},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1,2,3,4,5,6,7],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/compiler/rust/rust-std/wide-shapes/provenance.json b/compiler/rust/rust-std/wide-shapes/provenance.json index 7869315ba..3aad06c03 100644 --- a/compiler/rust/rust-std/wide-shapes/provenance.json +++ b/compiler/rust/rust-std/wide-shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"415c3a0d89f14d73987b411bad9cab765e5cda57c0d5271fa87d0341d6507918","src/lib.rs":"2fc8cd4e24bccd554f7e80296b25f799a403dadc4d2d29a70c28f5e03005143a"},"name":"wide_shapes_std","profile":"rust-std","program":"d0de8fa403502aaf54be1ccfae31401db4a92de6aa9ae953b340395fe2de28ec","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["c8f5fdecd4eefbea9d5648c31c7d3f792f742fa8bfec23cfde9d3c0fc99ee517"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"415c3a0d89f14d73987b411bad9cab765e5cda57c0d5271fa87d0341d6507918","src/lib.rs":"2fc8cd4e24bccd554f7e80296b25f799a403dadc4d2d29a70c28f5e03005143a"},"name":"wide_shapes_std","profile":"rust-std","program":"d0de8fa403502aaf54be1ccfae31401db4a92de6aa9ae953b340395fe2de28ec","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e36982ff9545254b9a90d88b07a1ff91624e3016601aeadadf87c9934f8554cb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/examples/collections/expected/build/manifest.json b/examples/collections/expected/build/manifest.json index 720ecfbb8..7105e0381 100644 --- a/examples/collections/expected/build/manifest.json +++ b/examples/collections/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"52ca3fdc7cf7417df8b66378c6b95f366a30a1c78748c1fdab7c85a1277cf863","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"8cbd56bf470c1660a0d45176b3f719de8f0b42afe7e7418f8bfd71adad6da892"},{"byte_length":644,"kind":"project-config","path":"lexlean.toml","sha256":"87b05dc405590c51e9a51ac60ef00f9096c4a38c29b9bab379a02d5c6a1cd744"},{"byte_length":18677,"kind":"source","path":"src/Main.lex.tex","sha256":"75d9370d719bc1634123f79db391070eda6061e88c461626129911161efa63a9"},{"byte_length":550,"kind":"source","path":"src/Measure.lex.tex","sha256":"227f5dad1ec06da3d2759ffa2ab2d4908aa5a02880ca0219bc46169089be9081"},{"byte_length":1620,"kind":"source","path":"src/Tables.lex.tex","sha256":"f5e7c1b714c8eee02fedacfb367c7e64dc01664eaa41fb48f4e42ae37aef43f0"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Collections.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Collections.Measure","module":"Measure","source_path":"src/Measure.lex.tex"},{"lean_module":"Collections.Tables","module":"Tables","source_path":"src/Tables.lex.tex"}],"outputs":[{"byte_length":21846,"kind":"coverage","path":"coverage/Collections/Main.coverage.json","sha256":"be10513f257ec431bec3263ed332d7ff9781c9e345d8afd5d856d0be3bb2f4d6"},{"byte_length":7799,"kind":"coverage","path":"coverage/Collections/Measure.coverage.json","sha256":"6d77336208aa88befdcc66039951d5a307d68179653e5d5026df24ab1aa245ce"},{"byte_length":7956,"kind":"coverage","path":"coverage/Collections/Tables.coverage.json","sha256":"3fff848e16180ce1689e5bba8289953d21cb5e9e34ca8ee6c2266f678133c434"},{"byte_length":14135,"kind":"lean","path":"modules/Collections/Main.lean","sha256":"455526e5c3f8dc239041d1652cc455bfff6097b7f53396f9235f27c138d42318"},{"byte_length":569,"kind":"lean","path":"modules/Collections/Measure.lean","sha256":"7d5af864fa1a79d11b37dd77d3a3d330caf8ed8a76cab5049a5cb882d8c0abeb"},{"byte_length":1328,"kind":"lean","path":"modules/Collections/Tables.lean","sha256":"0b51fd70df2b936977dca55fca83a38aa0048197b139186bc14b5d49e6d394fd"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10605,"kind":"lexicon-closure","path":"lexicons/Measure.closure.json","sha256":"624095a690526571fd42d5aa56a92d3fe7bc0953f3148c7535b69201e497e783"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Tables.closure.json","sha256":"28c6adc505e1fcd48a5d3d5dda53c47f2ff7818607748bb77ffeb26a241c7b29"},{"byte_length":17922,"kind":"map","path":"maps/Collections/Main.map.json","sha256":"57c46b5bd75e535896245485bbbbc9bfc96046c52c5d8c6d4c9c014266c2e9d9"},{"byte_length":1667,"kind":"map","path":"maps/Collections/Measure.map.json","sha256":"92b82dc7111b6e99b5bf2bb41b68c8beaa83636800c826e5742748416e37cbb2"},{"byte_length":2627,"kind":"map","path":"maps/Collections/Tables.map.json","sha256":"ece5f23c2637c72066f07dfaaaf20ee663147c6d91d2c8129b96c4304ed9213b"},{"byte_length":20493,"kind":"tex","path":"modules/Collections/Main.tex","sha256":"5da0ed1c1437f937d741891494e5371b54a01d16295ce1d1405a87826d3d15fa"},{"byte_length":714,"kind":"tex","path":"modules/Collections/Measure.tex","sha256":"0ee1d42862fc24ddb8624de071a22a2f54712440d10275f524d18ff29d9dd4e6"},{"byte_length":2287,"kind":"tex","path":"modules/Collections/Tables.tex","sha256":"92a01628c5c75c23c0e57a062ae6c0043c3a876d2a0bd077eb7d965913eb6abf"}],"project":"collections","selection":["Main","Measure","Tables"],"semantic_id":"9962d043362f4a167c67517d483f0f2432f8ee9485a2eb221e128b9491113c00","source_id":"f9fc0327d1cd85598a9abd472c45532aec5e6da8e748cf96072d3c5e098ab9b6","spec":"lexlean/build-manifest/1"} +{"build_id":"30ff66aa2215054c936fffb65158c822fde618c6de324215cad3af60faf123b5","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"2d6a1e459dcb88409b4f13d80db653a3bdc012a8b40872dfa600d4b90a562de2"},{"byte_length":644,"kind":"project-config","path":"lexlean.toml","sha256":"87b05dc405590c51e9a51ac60ef00f9096c4a38c29b9bab379a02d5c6a1cd744"},{"byte_length":18677,"kind":"source","path":"src/Main.lex.tex","sha256":"75d9370d719bc1634123f79db391070eda6061e88c461626129911161efa63a9"},{"byte_length":550,"kind":"source","path":"src/Measure.lex.tex","sha256":"227f5dad1ec06da3d2759ffa2ab2d4908aa5a02880ca0219bc46169089be9081"},{"byte_length":1620,"kind":"source","path":"src/Tables.lex.tex","sha256":"f5e7c1b714c8eee02fedacfb367c7e64dc01664eaa41fb48f4e42ae37aef43f0"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Collections.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Collections.Measure","module":"Measure","source_path":"src/Measure.lex.tex"},{"lean_module":"Collections.Tables","module":"Tables","source_path":"src/Tables.lex.tex"}],"outputs":[{"byte_length":21846,"kind":"coverage","path":"coverage/Collections/Main.coverage.json","sha256":"be10513f257ec431bec3263ed332d7ff9781c9e345d8afd5d856d0be3bb2f4d6"},{"byte_length":7799,"kind":"coverage","path":"coverage/Collections/Measure.coverage.json","sha256":"6d77336208aa88befdcc66039951d5a307d68179653e5d5026df24ab1aa245ce"},{"byte_length":7956,"kind":"coverage","path":"coverage/Collections/Tables.coverage.json","sha256":"3fff848e16180ce1689e5bba8289953d21cb5e9e34ca8ee6c2266f678133c434"},{"byte_length":14135,"kind":"lean","path":"modules/Collections/Main.lean","sha256":"455526e5c3f8dc239041d1652cc455bfff6097b7f53396f9235f27c138d42318"},{"byte_length":569,"kind":"lean","path":"modules/Collections/Measure.lean","sha256":"7d5af864fa1a79d11b37dd77d3a3d330caf8ed8a76cab5049a5cb882d8c0abeb"},{"byte_length":1328,"kind":"lean","path":"modules/Collections/Tables.lean","sha256":"0b51fd70df2b936977dca55fca83a38aa0048197b139186bc14b5d49e6d394fd"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10605,"kind":"lexicon-closure","path":"lexicons/Measure.closure.json","sha256":"624095a690526571fd42d5aa56a92d3fe7bc0953f3148c7535b69201e497e783"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Tables.closure.json","sha256":"28c6adc505e1fcd48a5d3d5dda53c47f2ff7818607748bb77ffeb26a241c7b29"},{"byte_length":17922,"kind":"map","path":"maps/Collections/Main.map.json","sha256":"c119eda0f2f6af44b29980fa0145d786ab25b2da0e31484090e2a8f71b0d0adf"},{"byte_length":1667,"kind":"map","path":"maps/Collections/Measure.map.json","sha256":"47a06a857dd2ef0825a8e49dd5161fab1930fc314b158d0ef5594fbaa411d939"},{"byte_length":2627,"kind":"map","path":"maps/Collections/Tables.map.json","sha256":"9f6c60d217a33d459ad9613d3f59fbe61616504b12a9fb154b72d311b1978881"},{"byte_length":20493,"kind":"tex","path":"modules/Collections/Main.tex","sha256":"5da0ed1c1437f937d741891494e5371b54a01d16295ce1d1405a87826d3d15fa"},{"byte_length":714,"kind":"tex","path":"modules/Collections/Measure.tex","sha256":"0ee1d42862fc24ddb8624de071a22a2f54712440d10275f524d18ff29d9dd4e6"},{"byte_length":2287,"kind":"tex","path":"modules/Collections/Tables.tex","sha256":"92a01628c5c75c23c0e57a062ae6c0043c3a876d2a0bd077eb7d965913eb6abf"}],"project":"collections","selection":["Main","Measure","Tables"],"semantic_id":"0f6d359d50d0d086f47af2c0608b2e13253fe1d63025e4c861d89779908d9890","source_id":"282120f2cc10752f544cd95f7085068b83e51e26ba43cddd8e064dfd84869823","spec":"lexlean/build-manifest/1"} diff --git a/examples/collections/expected/build/maps/Collections/Main.map.json b/examples/collections/expected/build/maps/Collections/Main.map.json index 8c0d65623..58a24a0b8 100644 --- a/examples/collections/expected/build/maps/Collections/Main.map.json +++ b/examples/collections/expected/build/maps/Collections/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Main.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Main.tex"}],"mappings":[{"artifact":0,"gen_end":345,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":0,"gen_end":1240,"gen_start":345,"node":1,"role":"declaration","source":0,"src_end":978,"src_start":158},{"artifact":0,"gen_end":1355,"gen_start":1240,"node":2,"role":"declaration","source":0,"src_end":1134,"src_start":980},{"artifact":0,"gen_end":1548,"gen_start":1355,"node":3,"role":"declaration","source":0,"src_end":1471,"src_start":1136},{"artifact":0,"gen_end":1739,"gen_start":1548,"node":4,"role":"declaration","source":0,"src_end":1730,"src_start":1473},{"artifact":0,"gen_end":1913,"gen_start":1739,"node":5,"role":"declaration","source":0,"src_end":2007,"src_start":1732},{"artifact":0,"gen_end":2041,"gen_start":1913,"node":6,"role":"declaration","source":0,"src_end":2249,"src_start":2009},{"artifact":0,"gen_end":2227,"gen_start":2041,"node":7,"role":"declaration","source":0,"src_end":2535,"src_start":2251},{"artifact":0,"gen_end":2387,"gen_start":2227,"node":8,"role":"declaration","source":0,"src_end":2783,"src_start":2537},{"artifact":0,"gen_end":2524,"gen_start":2387,"node":9,"role":"declaration","source":0,"src_end":2938,"src_start":2785},{"artifact":0,"gen_end":2689,"gen_start":2524,"node":10,"role":"declaration","source":0,"src_end":3245,"src_start":2940},{"artifact":0,"gen_end":2926,"gen_start":2689,"node":11,"role":"declaration","source":0,"src_end":3666,"src_start":3247},{"artifact":0,"gen_end":3162,"gen_start":2926,"node":12,"role":"declaration","source":0,"src_end":4074,"src_start":3668},{"artifact":0,"gen_end":3375,"gen_start":3162,"node":13,"role":"declaration","source":0,"src_end":4449,"src_start":4076},{"artifact":0,"gen_end":3605,"gen_start":3375,"node":14,"role":"declaration","source":0,"src_end":4853,"src_start":4451},{"artifact":0,"gen_end":3778,"gen_start":3605,"node":15,"role":"declaration","source":0,"src_end":5165,"src_start":4855},{"artifact":0,"gen_end":3954,"gen_start":3778,"node":16,"role":"declaration","source":0,"src_end":5482,"src_start":5167},{"artifact":0,"gen_end":4112,"gen_start":3954,"node":17,"role":"declaration","source":0,"src_end":5768,"src_start":5484},{"artifact":0,"gen_end":4252,"gen_start":4112,"node":18,"role":"declaration","source":0,"src_end":5987,"src_start":5770},{"artifact":0,"gen_end":4439,"gen_start":4252,"node":19,"role":"declaration","source":0,"src_end":6249,"src_start":5989},{"artifact":0,"gen_end":4620,"gen_start":4439,"node":20,"role":"declaration","source":0,"src_end":6505,"src_start":6251},{"artifact":0,"gen_end":4853,"gen_start":4620,"node":21,"role":"declaration","source":0,"src_end":6799,"src_start":6507},{"artifact":0,"gen_end":5147,"gen_start":4853,"node":22,"role":"declaration","source":0,"src_end":7157,"src_start":6801},{"artifact":0,"gen_end":5301,"gen_start":5147,"node":23,"role":"declaration","source":0,"src_end":7387,"src_start":7159},{"artifact":0,"gen_end":5449,"gen_start":5301,"node":24,"role":"declaration","source":0,"src_end":7611,"src_start":7389},{"artifact":0,"gen_end":5579,"gen_start":5449,"node":25,"role":"declaration","source":0,"src_end":7784,"src_start":7613},{"artifact":0,"gen_end":5692,"gen_start":5579,"node":26,"role":"declaration","source":0,"src_end":7942,"src_start":7786},{"artifact":0,"gen_end":5857,"gen_start":5692,"node":27,"role":"declaration","source":0,"src_end":8162,"src_start":7944},{"artifact":0,"gen_end":6032,"gen_start":5857,"node":28,"role":"declaration","source":0,"src_end":8447,"src_start":8164},{"artifact":0,"gen_end":6215,"gen_start":6032,"node":29,"role":"declaration","source":0,"src_end":8740,"src_start":8449},{"artifact":0,"gen_end":6388,"gen_start":6215,"node":30,"role":"declaration","source":0,"src_end":9023,"src_start":8742},{"artifact":0,"gen_end":6636,"gen_start":6388,"node":31,"role":"declaration","source":0,"src_end":9316,"src_start":9025},{"artifact":0,"gen_end":6900,"gen_start":6636,"node":32,"role":"declaration","source":0,"src_end":9589,"src_start":9318},{"artifact":0,"gen_end":7035,"gen_start":6900,"node":33,"role":"declaration","source":0,"src_end":9742,"src_start":9591},{"artifact":0,"gen_end":7276,"gen_start":7035,"node":34,"role":"declaration","source":0,"src_end":10010,"src_start":9744},{"artifact":0,"gen_end":7515,"gen_start":7276,"node":35,"role":"declaration","source":0,"src_end":10276,"src_start":10012},{"artifact":0,"gen_end":7728,"gen_start":7515,"node":36,"role":"declaration","source":0,"src_end":10650,"src_start":10278},{"artifact":0,"gen_end":7944,"gen_start":7728,"node":37,"role":"declaration","source":0,"src_end":11027,"src_start":10652},{"artifact":0,"gen_end":8155,"gen_start":7944,"node":38,"role":"declaration","source":0,"src_end":11420,"src_start":11029},{"artifact":0,"gen_end":8413,"gen_start":8155,"node":39,"role":"declaration","source":0,"src_end":11838,"src_start":11422},{"artifact":0,"gen_end":8731,"gen_start":8413,"node":40,"role":"declaration","source":0,"src_end":12225,"src_start":11840},{"artifact":0,"gen_end":9189,"gen_start":8731,"node":41,"role":"declaration","source":0,"src_end":12756,"src_start":12227},{"artifact":0,"gen_end":9639,"gen_start":9189,"node":42,"role":"declaration","source":0,"src_end":13277,"src_start":12758},{"artifact":0,"gen_end":10121,"gen_start":9639,"node":43,"role":"declaration","source":0,"src_end":13872,"src_start":13279},{"artifact":0,"gen_end":10627,"gen_start":10121,"node":44,"role":"declaration","source":0,"src_end":14491,"src_start":13874},{"artifact":0,"gen_end":11165,"gen_start":10627,"node":45,"role":"declaration","source":0,"src_end":15142,"src_start":14493},{"artifact":0,"gen_end":11567,"gen_start":11165,"node":46,"role":"declaration","source":0,"src_end":15611,"src_start":15144},{"artifact":0,"gen_end":11989,"gen_start":11567,"node":47,"role":"declaration","source":0,"src_end":16100,"src_start":15613},{"artifact":0,"gen_end":12425,"gen_start":11989,"node":48,"role":"declaration","source":0,"src_end":16603,"src_start":16102},{"artifact":0,"gen_end":12877,"gen_start":12425,"node":49,"role":"declaration","source":0,"src_end":17122,"src_start":16605},{"artifact":0,"gen_end":13179,"gen_start":12877,"node":50,"role":"declaration","source":0,"src_end":17508,"src_start":17124},{"artifact":0,"gen_end":13627,"gen_start":13179,"node":51,"role":"declaration","source":0,"src_end":18086,"src_start":17510},{"artifact":0,"gen_end":14113,"gen_start":13627,"node":52,"role":"declaration","source":0,"src_end":18641,"src_start":18088},{"artifact":0,"gen_end":14135,"gen_start":14113,"node":0,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":53,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":1,"gen_end":1512,"gen_start":134,"node":54,"role":"declaration","source":0,"src_end":978,"src_start":158},{"artifact":1,"gen_end":1772,"gen_start":1512,"node":55,"role":"declaration","source":0,"src_end":1134,"src_start":980},{"artifact":1,"gen_end":2113,"gen_start":1772,"node":56,"role":"declaration","source":0,"src_end":1471,"src_start":1136},{"artifact":1,"gen_end":2452,"gen_start":2113,"node":57,"role":"declaration","source":0,"src_end":1730,"src_start":1473},{"artifact":1,"gen_end":2774,"gen_start":2452,"node":58,"role":"declaration","source":0,"src_end":2007,"src_start":1732},{"artifact":1,"gen_end":3051,"gen_start":2774,"node":59,"role":"declaration","source":0,"src_end":2249,"src_start":2009},{"artifact":1,"gen_end":3346,"gen_start":3051,"node":60,"role":"declaration","source":0,"src_end":2535,"src_start":2251},{"artifact":1,"gen_end":3624,"gen_start":3346,"node":61,"role":"declaration","source":0,"src_end":2783,"src_start":2537},{"artifact":1,"gen_end":3868,"gen_start":3624,"node":62,"role":"declaration","source":0,"src_end":2938,"src_start":2785},{"artifact":1,"gen_end":4144,"gen_start":3868,"node":63,"role":"declaration","source":0,"src_end":3245,"src_start":2940},{"artifact":1,"gen_end":4522,"gen_start":4144,"node":64,"role":"declaration","source":0,"src_end":3666,"src_start":3247},{"artifact":1,"gen_end":4900,"gen_start":4522,"node":65,"role":"declaration","source":0,"src_end":4074,"src_start":3668},{"artifact":1,"gen_end":5254,"gen_start":4900,"node":66,"role":"declaration","source":0,"src_end":4449,"src_start":4076},{"artifact":1,"gen_end":5626,"gen_start":5254,"node":67,"role":"declaration","source":0,"src_end":4853,"src_start":4451},{"artifact":1,"gen_end":5948,"gen_start":5626,"node":68,"role":"declaration","source":0,"src_end":5165,"src_start":4855},{"artifact":1,"gen_end":6274,"gen_start":5948,"node":69,"role":"declaration","source":0,"src_end":5482,"src_start":5167},{"artifact":1,"gen_end":6581,"gen_start":6274,"node":70,"role":"declaration","source":0,"src_end":5768,"src_start":5484},{"artifact":1,"gen_end":6829,"gen_start":6581,"node":71,"role":"declaration","source":0,"src_end":5987,"src_start":5770},{"artifact":1,"gen_end":7124,"gen_start":6829,"node":72,"role":"declaration","source":0,"src_end":6249,"src_start":5989},{"artifact":1,"gen_end":7413,"gen_start":7124,"node":73,"role":"declaration","source":0,"src_end":6505,"src_start":6251},{"artifact":1,"gen_end":7754,"gen_start":7413,"node":74,"role":"declaration","source":0,"src_end":6799,"src_start":6507},{"artifact":1,"gen_end":8157,"gen_start":7754,"node":75,"role":"declaration","source":0,"src_end":7157,"src_start":6801},{"artifact":1,"gen_end":8418,"gen_start":8157,"node":76,"role":"declaration","source":0,"src_end":7387,"src_start":7159},{"artifact":1,"gen_end":8673,"gen_start":8418,"node":77,"role":"declaration","source":0,"src_end":7611,"src_start":7389},{"artifact":1,"gen_end":8911,"gen_start":8673,"node":78,"role":"declaration","source":0,"src_end":7784,"src_start":7613},{"artifact":1,"gen_end":9132,"gen_start":8911,"node":79,"role":"declaration","source":0,"src_end":7942,"src_start":7786},{"artifact":1,"gen_end":9405,"gen_start":9132,"node":80,"role":"declaration","source":0,"src_end":8162,"src_start":7944},{"artifact":1,"gen_end":9687,"gen_start":9405,"node":81,"role":"declaration","source":0,"src_end":8447,"src_start":8164},{"artifact":1,"gen_end":9977,"gen_start":9687,"node":82,"role":"declaration","source":0,"src_end":8740,"src_start":8449},{"artifact":1,"gen_end":10257,"gen_start":9977,"node":83,"role":"declaration","source":0,"src_end":9023,"src_start":8742},{"artifact":1,"gen_end":10613,"gen_start":10257,"node":84,"role":"declaration","source":0,"src_end":9316,"src_start":9025},{"artifact":1,"gen_end":10985,"gen_start":10613,"node":85,"role":"declaration","source":0,"src_end":9589,"src_start":9318},{"artifact":1,"gen_end":11228,"gen_start":10985,"node":86,"role":"declaration","source":0,"src_end":9742,"src_start":9591},{"artifact":1,"gen_end":11579,"gen_start":11228,"node":87,"role":"declaration","source":0,"src_end":10010,"src_start":9744},{"artifact":1,"gen_end":11927,"gen_start":11579,"node":88,"role":"declaration","source":0,"src_end":10276,"src_start":10012},{"artifact":1,"gen_end":12247,"gen_start":11927,"node":89,"role":"declaration","source":0,"src_end":10650,"src_start":10278},{"artifact":1,"gen_end":12571,"gen_start":12247,"node":90,"role":"declaration","source":0,"src_end":11027,"src_start":10652},{"artifact":1,"gen_end":12900,"gen_start":12571,"node":91,"role":"declaration","source":0,"src_end":11420,"src_start":11029},{"artifact":1,"gen_end":13266,"gen_start":12900,"node":92,"role":"declaration","source":0,"src_end":11838,"src_start":11422},{"artifact":1,"gen_end":13689,"gen_start":13266,"node":93,"role":"declaration","source":0,"src_end":12225,"src_start":11840},{"artifact":1,"gen_end":14252,"gen_start":13689,"node":94,"role":"declaration","source":0,"src_end":12756,"src_start":12227},{"artifact":1,"gen_end":14807,"gen_start":14252,"node":95,"role":"declaration","source":0,"src_end":13277,"src_start":12758},{"artifact":1,"gen_end":15394,"gen_start":14807,"node":96,"role":"declaration","source":0,"src_end":13872,"src_start":13279},{"artifact":1,"gen_end":16005,"gen_start":15394,"node":97,"role":"declaration","source":0,"src_end":14491,"src_start":13874},{"artifact":1,"gen_end":16648,"gen_start":16005,"node":98,"role":"declaration","source":0,"src_end":15142,"src_start":14493},{"artifact":1,"gen_end":17155,"gen_start":16648,"node":99,"role":"declaration","source":0,"src_end":15611,"src_start":15144},{"artifact":1,"gen_end":17682,"gen_start":17155,"node":100,"role":"declaration","source":0,"src_end":16100,"src_start":15613},{"artifact":1,"gen_end":18223,"gen_start":17682,"node":101,"role":"declaration","source":0,"src_end":16603,"src_start":16102},{"artifact":1,"gen_end":18780,"gen_start":18223,"node":102,"role":"declaration","source":0,"src_end":17122,"src_start":16605},{"artifact":1,"gen_end":19198,"gen_start":18780,"node":103,"role":"declaration","source":0,"src_end":17508,"src_start":17124},{"artifact":1,"gen_end":19846,"gen_start":19198,"node":104,"role":"declaration","source":0,"src_end":18086,"src_start":17510},{"artifact":1,"gen_end":20478,"gen_start":19846,"node":105,"role":"declaration","source":0,"src_end":18641,"src_start":18088},{"artifact":1,"gen_end":20493,"gen_start":20478,"node":53,"role":"declaration","source":0,"src_end":18677,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-latex-module"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"}],"semantic_id":"9962d043362f4a167c67517d483f0f2432f8ee9485a2eb221e128b9491113c00","source_id":"f9fc0327d1cd85598a9abd472c45532aec5e6da8e748cf96072d3c5e098ab9b6","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"75d9370d719bc1634123f79db391070eda6061e88c461626129911161efa63a9"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Main.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Main.tex"}],"mappings":[{"artifact":0,"gen_end":345,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":0,"gen_end":1240,"gen_start":345,"node":1,"role":"declaration","source":0,"src_end":978,"src_start":158},{"artifact":0,"gen_end":1355,"gen_start":1240,"node":2,"role":"declaration","source":0,"src_end":1134,"src_start":980},{"artifact":0,"gen_end":1548,"gen_start":1355,"node":3,"role":"declaration","source":0,"src_end":1471,"src_start":1136},{"artifact":0,"gen_end":1739,"gen_start":1548,"node":4,"role":"declaration","source":0,"src_end":1730,"src_start":1473},{"artifact":0,"gen_end":1913,"gen_start":1739,"node":5,"role":"declaration","source":0,"src_end":2007,"src_start":1732},{"artifact":0,"gen_end":2041,"gen_start":1913,"node":6,"role":"declaration","source":0,"src_end":2249,"src_start":2009},{"artifact":0,"gen_end":2227,"gen_start":2041,"node":7,"role":"declaration","source":0,"src_end":2535,"src_start":2251},{"artifact":0,"gen_end":2387,"gen_start":2227,"node":8,"role":"declaration","source":0,"src_end":2783,"src_start":2537},{"artifact":0,"gen_end":2524,"gen_start":2387,"node":9,"role":"declaration","source":0,"src_end":2938,"src_start":2785},{"artifact":0,"gen_end":2689,"gen_start":2524,"node":10,"role":"declaration","source":0,"src_end":3245,"src_start":2940},{"artifact":0,"gen_end":2926,"gen_start":2689,"node":11,"role":"declaration","source":0,"src_end":3666,"src_start":3247},{"artifact":0,"gen_end":3162,"gen_start":2926,"node":12,"role":"declaration","source":0,"src_end":4074,"src_start":3668},{"artifact":0,"gen_end":3375,"gen_start":3162,"node":13,"role":"declaration","source":0,"src_end":4449,"src_start":4076},{"artifact":0,"gen_end":3605,"gen_start":3375,"node":14,"role":"declaration","source":0,"src_end":4853,"src_start":4451},{"artifact":0,"gen_end":3778,"gen_start":3605,"node":15,"role":"declaration","source":0,"src_end":5165,"src_start":4855},{"artifact":0,"gen_end":3954,"gen_start":3778,"node":16,"role":"declaration","source":0,"src_end":5482,"src_start":5167},{"artifact":0,"gen_end":4112,"gen_start":3954,"node":17,"role":"declaration","source":0,"src_end":5768,"src_start":5484},{"artifact":0,"gen_end":4252,"gen_start":4112,"node":18,"role":"declaration","source":0,"src_end":5987,"src_start":5770},{"artifact":0,"gen_end":4439,"gen_start":4252,"node":19,"role":"declaration","source":0,"src_end":6249,"src_start":5989},{"artifact":0,"gen_end":4620,"gen_start":4439,"node":20,"role":"declaration","source":0,"src_end":6505,"src_start":6251},{"artifact":0,"gen_end":4853,"gen_start":4620,"node":21,"role":"declaration","source":0,"src_end":6799,"src_start":6507},{"artifact":0,"gen_end":5147,"gen_start":4853,"node":22,"role":"declaration","source":0,"src_end":7157,"src_start":6801},{"artifact":0,"gen_end":5301,"gen_start":5147,"node":23,"role":"declaration","source":0,"src_end":7387,"src_start":7159},{"artifact":0,"gen_end":5449,"gen_start":5301,"node":24,"role":"declaration","source":0,"src_end":7611,"src_start":7389},{"artifact":0,"gen_end":5579,"gen_start":5449,"node":25,"role":"declaration","source":0,"src_end":7784,"src_start":7613},{"artifact":0,"gen_end":5692,"gen_start":5579,"node":26,"role":"declaration","source":0,"src_end":7942,"src_start":7786},{"artifact":0,"gen_end":5857,"gen_start":5692,"node":27,"role":"declaration","source":0,"src_end":8162,"src_start":7944},{"artifact":0,"gen_end":6032,"gen_start":5857,"node":28,"role":"declaration","source":0,"src_end":8447,"src_start":8164},{"artifact":0,"gen_end":6215,"gen_start":6032,"node":29,"role":"declaration","source":0,"src_end":8740,"src_start":8449},{"artifact":0,"gen_end":6388,"gen_start":6215,"node":30,"role":"declaration","source":0,"src_end":9023,"src_start":8742},{"artifact":0,"gen_end":6636,"gen_start":6388,"node":31,"role":"declaration","source":0,"src_end":9316,"src_start":9025},{"artifact":0,"gen_end":6900,"gen_start":6636,"node":32,"role":"declaration","source":0,"src_end":9589,"src_start":9318},{"artifact":0,"gen_end":7035,"gen_start":6900,"node":33,"role":"declaration","source":0,"src_end":9742,"src_start":9591},{"artifact":0,"gen_end":7276,"gen_start":7035,"node":34,"role":"declaration","source":0,"src_end":10010,"src_start":9744},{"artifact":0,"gen_end":7515,"gen_start":7276,"node":35,"role":"declaration","source":0,"src_end":10276,"src_start":10012},{"artifact":0,"gen_end":7728,"gen_start":7515,"node":36,"role":"declaration","source":0,"src_end":10650,"src_start":10278},{"artifact":0,"gen_end":7944,"gen_start":7728,"node":37,"role":"declaration","source":0,"src_end":11027,"src_start":10652},{"artifact":0,"gen_end":8155,"gen_start":7944,"node":38,"role":"declaration","source":0,"src_end":11420,"src_start":11029},{"artifact":0,"gen_end":8413,"gen_start":8155,"node":39,"role":"declaration","source":0,"src_end":11838,"src_start":11422},{"artifact":0,"gen_end":8731,"gen_start":8413,"node":40,"role":"declaration","source":0,"src_end":12225,"src_start":11840},{"artifact":0,"gen_end":9189,"gen_start":8731,"node":41,"role":"declaration","source":0,"src_end":12756,"src_start":12227},{"artifact":0,"gen_end":9639,"gen_start":9189,"node":42,"role":"declaration","source":0,"src_end":13277,"src_start":12758},{"artifact":0,"gen_end":10121,"gen_start":9639,"node":43,"role":"declaration","source":0,"src_end":13872,"src_start":13279},{"artifact":0,"gen_end":10627,"gen_start":10121,"node":44,"role":"declaration","source":0,"src_end":14491,"src_start":13874},{"artifact":0,"gen_end":11165,"gen_start":10627,"node":45,"role":"declaration","source":0,"src_end":15142,"src_start":14493},{"artifact":0,"gen_end":11567,"gen_start":11165,"node":46,"role":"declaration","source":0,"src_end":15611,"src_start":15144},{"artifact":0,"gen_end":11989,"gen_start":11567,"node":47,"role":"declaration","source":0,"src_end":16100,"src_start":15613},{"artifact":0,"gen_end":12425,"gen_start":11989,"node":48,"role":"declaration","source":0,"src_end":16603,"src_start":16102},{"artifact":0,"gen_end":12877,"gen_start":12425,"node":49,"role":"declaration","source":0,"src_end":17122,"src_start":16605},{"artifact":0,"gen_end":13179,"gen_start":12877,"node":50,"role":"declaration","source":0,"src_end":17508,"src_start":17124},{"artifact":0,"gen_end":13627,"gen_start":13179,"node":51,"role":"declaration","source":0,"src_end":18086,"src_start":17510},{"artifact":0,"gen_end":14113,"gen_start":13627,"node":52,"role":"declaration","source":0,"src_end":18641,"src_start":18088},{"artifact":0,"gen_end":14135,"gen_start":14113,"node":0,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":53,"role":"declaration","source":0,"src_end":18677,"src_start":0},{"artifact":1,"gen_end":1512,"gen_start":134,"node":54,"role":"declaration","source":0,"src_end":978,"src_start":158},{"artifact":1,"gen_end":1772,"gen_start":1512,"node":55,"role":"declaration","source":0,"src_end":1134,"src_start":980},{"artifact":1,"gen_end":2113,"gen_start":1772,"node":56,"role":"declaration","source":0,"src_end":1471,"src_start":1136},{"artifact":1,"gen_end":2452,"gen_start":2113,"node":57,"role":"declaration","source":0,"src_end":1730,"src_start":1473},{"artifact":1,"gen_end":2774,"gen_start":2452,"node":58,"role":"declaration","source":0,"src_end":2007,"src_start":1732},{"artifact":1,"gen_end":3051,"gen_start":2774,"node":59,"role":"declaration","source":0,"src_end":2249,"src_start":2009},{"artifact":1,"gen_end":3346,"gen_start":3051,"node":60,"role":"declaration","source":0,"src_end":2535,"src_start":2251},{"artifact":1,"gen_end":3624,"gen_start":3346,"node":61,"role":"declaration","source":0,"src_end":2783,"src_start":2537},{"artifact":1,"gen_end":3868,"gen_start":3624,"node":62,"role":"declaration","source":0,"src_end":2938,"src_start":2785},{"artifact":1,"gen_end":4144,"gen_start":3868,"node":63,"role":"declaration","source":0,"src_end":3245,"src_start":2940},{"artifact":1,"gen_end":4522,"gen_start":4144,"node":64,"role":"declaration","source":0,"src_end":3666,"src_start":3247},{"artifact":1,"gen_end":4900,"gen_start":4522,"node":65,"role":"declaration","source":0,"src_end":4074,"src_start":3668},{"artifact":1,"gen_end":5254,"gen_start":4900,"node":66,"role":"declaration","source":0,"src_end":4449,"src_start":4076},{"artifact":1,"gen_end":5626,"gen_start":5254,"node":67,"role":"declaration","source":0,"src_end":4853,"src_start":4451},{"artifact":1,"gen_end":5948,"gen_start":5626,"node":68,"role":"declaration","source":0,"src_end":5165,"src_start":4855},{"artifact":1,"gen_end":6274,"gen_start":5948,"node":69,"role":"declaration","source":0,"src_end":5482,"src_start":5167},{"artifact":1,"gen_end":6581,"gen_start":6274,"node":70,"role":"declaration","source":0,"src_end":5768,"src_start":5484},{"artifact":1,"gen_end":6829,"gen_start":6581,"node":71,"role":"declaration","source":0,"src_end":5987,"src_start":5770},{"artifact":1,"gen_end":7124,"gen_start":6829,"node":72,"role":"declaration","source":0,"src_end":6249,"src_start":5989},{"artifact":1,"gen_end":7413,"gen_start":7124,"node":73,"role":"declaration","source":0,"src_end":6505,"src_start":6251},{"artifact":1,"gen_end":7754,"gen_start":7413,"node":74,"role":"declaration","source":0,"src_end":6799,"src_start":6507},{"artifact":1,"gen_end":8157,"gen_start":7754,"node":75,"role":"declaration","source":0,"src_end":7157,"src_start":6801},{"artifact":1,"gen_end":8418,"gen_start":8157,"node":76,"role":"declaration","source":0,"src_end":7387,"src_start":7159},{"artifact":1,"gen_end":8673,"gen_start":8418,"node":77,"role":"declaration","source":0,"src_end":7611,"src_start":7389},{"artifact":1,"gen_end":8911,"gen_start":8673,"node":78,"role":"declaration","source":0,"src_end":7784,"src_start":7613},{"artifact":1,"gen_end":9132,"gen_start":8911,"node":79,"role":"declaration","source":0,"src_end":7942,"src_start":7786},{"artifact":1,"gen_end":9405,"gen_start":9132,"node":80,"role":"declaration","source":0,"src_end":8162,"src_start":7944},{"artifact":1,"gen_end":9687,"gen_start":9405,"node":81,"role":"declaration","source":0,"src_end":8447,"src_start":8164},{"artifact":1,"gen_end":9977,"gen_start":9687,"node":82,"role":"declaration","source":0,"src_end":8740,"src_start":8449},{"artifact":1,"gen_end":10257,"gen_start":9977,"node":83,"role":"declaration","source":0,"src_end":9023,"src_start":8742},{"artifact":1,"gen_end":10613,"gen_start":10257,"node":84,"role":"declaration","source":0,"src_end":9316,"src_start":9025},{"artifact":1,"gen_end":10985,"gen_start":10613,"node":85,"role":"declaration","source":0,"src_end":9589,"src_start":9318},{"artifact":1,"gen_end":11228,"gen_start":10985,"node":86,"role":"declaration","source":0,"src_end":9742,"src_start":9591},{"artifact":1,"gen_end":11579,"gen_start":11228,"node":87,"role":"declaration","source":0,"src_end":10010,"src_start":9744},{"artifact":1,"gen_end":11927,"gen_start":11579,"node":88,"role":"declaration","source":0,"src_end":10276,"src_start":10012},{"artifact":1,"gen_end":12247,"gen_start":11927,"node":89,"role":"declaration","source":0,"src_end":10650,"src_start":10278},{"artifact":1,"gen_end":12571,"gen_start":12247,"node":90,"role":"declaration","source":0,"src_end":11027,"src_start":10652},{"artifact":1,"gen_end":12900,"gen_start":12571,"node":91,"role":"declaration","source":0,"src_end":11420,"src_start":11029},{"artifact":1,"gen_end":13266,"gen_start":12900,"node":92,"role":"declaration","source":0,"src_end":11838,"src_start":11422},{"artifact":1,"gen_end":13689,"gen_start":13266,"node":93,"role":"declaration","source":0,"src_end":12225,"src_start":11840},{"artifact":1,"gen_end":14252,"gen_start":13689,"node":94,"role":"declaration","source":0,"src_end":12756,"src_start":12227},{"artifact":1,"gen_end":14807,"gen_start":14252,"node":95,"role":"declaration","source":0,"src_end":13277,"src_start":12758},{"artifact":1,"gen_end":15394,"gen_start":14807,"node":96,"role":"declaration","source":0,"src_end":13872,"src_start":13279},{"artifact":1,"gen_end":16005,"gen_start":15394,"node":97,"role":"declaration","source":0,"src_end":14491,"src_start":13874},{"artifact":1,"gen_end":16648,"gen_start":16005,"node":98,"role":"declaration","source":0,"src_end":15142,"src_start":14493},{"artifact":1,"gen_end":17155,"gen_start":16648,"node":99,"role":"declaration","source":0,"src_end":15611,"src_start":15144},{"artifact":1,"gen_end":17682,"gen_start":17155,"node":100,"role":"declaration","source":0,"src_end":16100,"src_start":15613},{"artifact":1,"gen_end":18223,"gen_start":17682,"node":101,"role":"declaration","source":0,"src_end":16603,"src_start":16102},{"artifact":1,"gen_end":18780,"gen_start":18223,"node":102,"role":"declaration","source":0,"src_end":17122,"src_start":16605},{"artifact":1,"gen_end":19198,"gen_start":18780,"node":103,"role":"declaration","source":0,"src_end":17508,"src_start":17124},{"artifact":1,"gen_end":19846,"gen_start":19198,"node":104,"role":"declaration","source":0,"src_end":18086,"src_start":17510},{"artifact":1,"gen_end":20478,"gen_start":19846,"node":105,"role":"declaration","source":0,"src_end":18641,"src_start":18088},{"artifact":1,"gen_end":20493,"gen_start":20478,"node":53,"role":"declaration","source":0,"src_end":18677,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-latex-module"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"}],"semantic_id":"0f6d359d50d0d086f47af2c0608b2e13253fe1d63025e4c861d89779908d9890","source_id":"282120f2cc10752f544cd95f7085068b83e51e26ba43cddd8e064dfd84869823","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"75d9370d719bc1634123f79db391070eda6061e88c461626129911161efa63a9"}],"spec":"lexlean/source-map/1"} diff --git a/examples/collections/expected/build/maps/Collections/Measure.map.json b/examples/collections/expected/build/maps/Collections/Measure.map.json index 32c58a169..317348774 100644 --- a/examples/collections/expected/build/maps/Collections/Measure.map.json +++ b/examples/collections/expected/build/maps/Collections/Measure.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Measure.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Measure.tex"}],"mappings":[{"artifact":0,"gen_end":314,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":0,"gen_end":476,"gen_start":314,"node":1,"role":"declaration","source":0,"src_end":355,"src_start":138},{"artifact":0,"gen_end":544,"gen_start":476,"node":2,"role":"declaration","source":0,"src_end":514,"src_start":357},{"artifact":0,"gen_end":569,"gen_start":544,"node":0,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":3,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":1,"gen_end":483,"gen_start":134,"node":4,"role":"declaration","source":0,"src_end":355,"src_start":138},{"artifact":1,"gen_end":699,"gen_start":483,"node":5,"role":"declaration","source":0,"src_end":514,"src_start":357},{"artifact":1,"gen_end":714,"gen_start":699,"node":3,"role":"declaration","source":0,"src_end":550,"src_start":0}],"module":"Measure","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-latex-module"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"}],"semantic_id":"9962d043362f4a167c67517d483f0f2432f8ee9485a2eb221e128b9491113c00","source_id":"f9fc0327d1cd85598a9abd472c45532aec5e6da8e748cf96072d3c5e098ab9b6","sources":[{"id":0,"kind":"file","path":"src/Measure.lex.tex","sha256":"227f5dad1ec06da3d2759ffa2ab2d4908aa5a02880ca0219bc46169089be9081"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Measure.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Measure.tex"}],"mappings":[{"artifact":0,"gen_end":314,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":0,"gen_end":476,"gen_start":314,"node":1,"role":"declaration","source":0,"src_end":355,"src_start":138},{"artifact":0,"gen_end":544,"gen_start":476,"node":2,"role":"declaration","source":0,"src_end":514,"src_start":357},{"artifact":0,"gen_end":569,"gen_start":544,"node":0,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":3,"role":"declaration","source":0,"src_end":550,"src_start":0},{"artifact":1,"gen_end":483,"gen_start":134,"node":4,"role":"declaration","source":0,"src_end":355,"src_start":138},{"artifact":1,"gen_end":699,"gen_start":483,"node":5,"role":"declaration","source":0,"src_end":514,"src_start":357},{"artifact":1,"gen_end":714,"gen_start":699,"node":3,"role":"declaration","source":0,"src_end":550,"src_start":0}],"module":"Measure","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-latex-module"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"}],"semantic_id":"0f6d359d50d0d086f47af2c0608b2e13253fe1d63025e4c861d89779908d9890","source_id":"282120f2cc10752f544cd95f7085068b83e51e26ba43cddd8e064dfd84869823","sources":[{"id":0,"kind":"file","path":"src/Measure.lex.tex","sha256":"227f5dad1ec06da3d2759ffa2ab2d4908aa5a02880ca0219bc46169089be9081"}],"spec":"lexlean/source-map/1"} diff --git a/examples/collections/expected/build/maps/Collections/Tables.map.json b/examples/collections/expected/build/maps/Collections/Tables.map.json index b49fc1e9f..4e37c82d2 100644 --- a/examples/collections/expected/build/maps/Collections/Tables.map.json +++ b/examples/collections/expected/build/maps/Collections/Tables.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Tables.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Tables.tex"}],"mappings":[{"artifact":0,"gen_end":280,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":0,"gen_end":490,"gen_start":280,"node":1,"role":"declaration","source":0,"src_end":374,"src_start":115},{"artifact":0,"gen_end":814,"gen_start":490,"node":2,"role":"declaration","source":0,"src_end":764,"src_start":376},{"artifact":0,"gen_end":1035,"gen_start":814,"node":3,"role":"declaration","source":0,"src_end":1175,"src_start":766},{"artifact":0,"gen_end":1170,"gen_start":1035,"node":4,"role":"declaration","source":0,"src_end":1382,"src_start":1177},{"artifact":0,"gen_end":1304,"gen_start":1170,"node":5,"role":"declaration","source":0,"src_end":1584,"src_start":1384},{"artifact":0,"gen_end":1328,"gen_start":1304,"node":0,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":6,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":1,"gen_end":608,"gen_start":134,"node":7,"role":"declaration","source":0,"src_end":374,"src_start":115},{"artifact":1,"gen_end":1273,"gen_start":608,"node":8,"role":"declaration","source":0,"src_end":764,"src_start":376},{"artifact":1,"gen_end":1631,"gen_start":1273,"node":9,"role":"declaration","source":0,"src_end":1175,"src_start":766},{"artifact":1,"gen_end":1953,"gen_start":1631,"node":10,"role":"declaration","source":0,"src_end":1382,"src_start":1177},{"artifact":1,"gen_end":2272,"gen_start":1953,"node":11,"role":"declaration","source":0,"src_end":1584,"src_start":1384},{"artifact":1,"gen_end":2287,"gen_start":2272,"node":6,"role":"declaration","source":0,"src_end":1620,"src_start":0}],"module":"Tables","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-latex-module"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"}],"semantic_id":"9962d043362f4a167c67517d483f0f2432f8ee9485a2eb221e128b9491113c00","source_id":"f9fc0327d1cd85598a9abd472c45532aec5e6da8e748cf96072d3c5e098ab9b6","sources":[{"id":0,"kind":"file","path":"src/Tables.lex.tex","sha256":"f5e7c1b714c8eee02fedacfb367c7e64dc01664eaa41fb48f4e42ae37aef43f0"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Collections/Tables.lean"},{"id":1,"kind":"tex","path":"modules/Collections/Tables.tex"}],"mappings":[{"artifact":0,"gen_end":280,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":0,"gen_end":490,"gen_start":280,"node":1,"role":"declaration","source":0,"src_end":374,"src_start":115},{"artifact":0,"gen_end":814,"gen_start":490,"node":2,"role":"declaration","source":0,"src_end":764,"src_start":376},{"artifact":0,"gen_end":1035,"gen_start":814,"node":3,"role":"declaration","source":0,"src_end":1175,"src_start":766},{"artifact":0,"gen_end":1170,"gen_start":1035,"node":4,"role":"declaration","source":0,"src_end":1382,"src_start":1177},{"artifact":0,"gen_end":1304,"gen_start":1170,"node":5,"role":"declaration","source":0,"src_end":1584,"src_start":1384},{"artifact":0,"gen_end":1328,"gen_start":1304,"node":0,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":6,"role":"declaration","source":0,"src_end":1620,"src_start":0},{"artifact":1,"gen_end":608,"gen_start":134,"node":7,"role":"declaration","source":0,"src_end":374,"src_start":115},{"artifact":1,"gen_end":1273,"gen_start":608,"node":8,"role":"declaration","source":0,"src_end":764,"src_start":376},{"artifact":1,"gen_end":1631,"gen_start":1273,"node":9,"role":"declaration","source":0,"src_end":1175,"src_start":766},{"artifact":1,"gen_end":1953,"gen_start":1631,"node":10,"role":"declaration","source":0,"src_end":1382,"src_start":1177},{"artifact":1,"gen_end":2272,"gen_start":1953,"node":11,"role":"declaration","source":0,"src_end":1584,"src_start":1384},{"artifact":1,"gen_end":2287,"gen_start":2272,"node":6,"role":"declaration","source":0,"src_end":1620,"src_start":0}],"module":"Tables","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-latex-module"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"}],"semantic_id":"0f6d359d50d0d086f47af2c0608b2e13253fe1d63025e4c861d89779908d9890","source_id":"282120f2cc10752f544cd95f7085068b83e51e26ba43cddd8e064dfd84869823","sources":[{"id":0,"kind":"file","path":"src/Tables.lex.tex","sha256":"f5e7c1b714c8eee02fedacfb367c7e64dc01664eaa41fb48f4e42ae37aef43f0"}],"spec":"lexlean/source-map/1"} diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.lean b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.lean similarity index 100% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.lean rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.lean diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.process.json b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.process.json similarity index 94% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.process.json rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.process.json index 9b1254498..dcd609a9c 100644 --- a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.process.json +++ b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Main.ancestor_closure' depends on axioms: [propext]\n'Collections.Main.ancestors' depends on axioms: [propext]\n'Collections.Main.bounded_iteration' does not depend on any axioms\n'Collections.Main.call_order' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.cycle_has_no_order' does not depend on any axioms\n'Collections.Main.family' does not depend on any axioms\n'Collections.Main.key_order_bool' depends on axioms: [propext]\n'Collections.Main.key_order_int' does not depend on any axioms\n'Collections.Main.key_order_int16' does not depend on any axioms\n'Collections.Main.key_order_int32' does not depend on any axioms\n'Collections.Main.key_order_int64' does not depend on any axioms\n'Collections.Main.key_order_int8' does not depend on any axioms\n'Collections.Main.key_order_nat' does not depend on any axioms\n'Collections.Main.key_order_product' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.key_order_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.key_order_uint16' does not depend on any axioms\n'Collections.Main.key_order_uint32' does not depend on any axioms\n'Collections.Main.key_order_uint64' does not depend on any axioms\n'Collections.Main.key_order_uint8' does not depend on any axioms\n'Collections.Main.op_graph_reachable' depends on axioms: [propext]\n'Collections.Main.op_graph_successors' does not depend on any axioms\n'Collections.Main.op_graph_successors_absent' does not depend on any axioms\n'Collections.Main.op_graph_topological' does not depend on any axioms\n'Collections.Main.op_iterate_until_exhausted' does not depend on any axioms\n'Collections.Main.op_iterate_until_fixed_point' does not depend on any axioms\n'Collections.Main.op_iterate_zero' does not depend on any axioms\n'Collections.Main.op_list_fold' does not depend on any axioms\n'Collections.Main.op_map_contains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_entries' does not depend on any axioms\n'Collections.Main.op_map_fold' does not depend on any axioms\n'Collections.Main.op_map_insert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_insert_replaces' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_keys' does not depend on any axioms\n'Collections.Main.op_map_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_lookup_absent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_remove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_remove_absent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_size' does not depend on any axioms\n'Collections.Main.op_map_values' does not depend on any axioms\n'Collections.Main.op_set_contains' does not depend on any axioms\n'Collections.Main.op_set_difference' does not depend on any axioms\n'Collections.Main.op_set_elements' does not depend on any axioms\n'Collections.Main.op_set_fold' does not depend on any axioms\n'Collections.Main.op_set_insert' does not depend on any axioms\n'Collections.Main.op_set_intersection' does not depend on any axioms\n'Collections.Main.op_set_remove' does not depend on any axioms\n'Collections.Main.op_set_size' does not depend on any axioms\n'Collections.Main.op_set_union' does not depend on any axioms\n'Collections.Main.parse_reaches_lex' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.reordered_literals_agree' does not depend on any axioms\n'Collections.Main.table_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.table_slots' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"3d77f9bcb113d76b5e385245365c454f35d99c86cb74e7dfeb18ce445b9a81e2","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Main.ancestor_closure' depends on axioms: [propext]\n'Collections.Main.ancestors' depends on axioms: [propext]\n'Collections.Main.bounded_iteration' does not depend on any axioms\n'Collections.Main.call_order' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.cycle_has_no_order' does not depend on any axioms\n'Collections.Main.family' does not depend on any axioms\n'Collections.Main.key_order_bool' depends on axioms: [propext]\n'Collections.Main.key_order_int' does not depend on any axioms\n'Collections.Main.key_order_int16' does not depend on any axioms\n'Collections.Main.key_order_int32' does not depend on any axioms\n'Collections.Main.key_order_int64' does not depend on any axioms\n'Collections.Main.key_order_int8' does not depend on any axioms\n'Collections.Main.key_order_nat' does not depend on any axioms\n'Collections.Main.key_order_product' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.key_order_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.key_order_uint16' does not depend on any axioms\n'Collections.Main.key_order_uint32' does not depend on any axioms\n'Collections.Main.key_order_uint64' does not depend on any axioms\n'Collections.Main.key_order_uint8' does not depend on any axioms\n'Collections.Main.op_graph_reachable' depends on axioms: [propext]\n'Collections.Main.op_graph_successors' does not depend on any axioms\n'Collections.Main.op_graph_successors_absent' does not depend on any axioms\n'Collections.Main.op_graph_topological' does not depend on any axioms\n'Collections.Main.op_iterate_until_exhausted' does not depend on any axioms\n'Collections.Main.op_iterate_until_fixed_point' does not depend on any axioms\n'Collections.Main.op_iterate_zero' does not depend on any axioms\n'Collections.Main.op_list_fold' does not depend on any axioms\n'Collections.Main.op_map_contains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_entries' does not depend on any axioms\n'Collections.Main.op_map_fold' does not depend on any axioms\n'Collections.Main.op_map_insert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_insert_replaces' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_keys' does not depend on any axioms\n'Collections.Main.op_map_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_lookup_absent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_remove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_remove_absent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.op_map_size' does not depend on any axioms\n'Collections.Main.op_map_values' does not depend on any axioms\n'Collections.Main.op_set_contains' does not depend on any axioms\n'Collections.Main.op_set_difference' does not depend on any axioms\n'Collections.Main.op_set_elements' does not depend on any axioms\n'Collections.Main.op_set_fold' does not depend on any axioms\n'Collections.Main.op_set_insert' does not depend on any axioms\n'Collections.Main.op_set_intersection' does not depend on any axioms\n'Collections.Main.op_set_remove' does not depend on any axioms\n'Collections.Main.op_set_size' does not depend on any axioms\n'Collections.Main.op_set_union' does not depend on any axioms\n'Collections.Main.parse_reaches_lex' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.reordered_literals_agree' does not depend on any axioms\n'Collections.Main.table_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Main.table_slots' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"3d77f9bcb113d76b5e385245365c454f35d99c86cb74e7dfeb18ce445b9a81e2","tool":"lean"} diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.lean b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.lean similarity index 100% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.lean rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.lean diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.process.json b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.process.json similarity index 60% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.process.json rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.process.json index f67bd64fe..005d59661 100644 --- a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.process.json +++ b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Measure","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Measure.distinctNames' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Measure.distinct_names' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"9a0b51347cf1806a3c5870dffe83294b16325a9e46b47bba1233e7e3fb48209e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Measure","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Measure.distinctNames' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Measure.distinct_names' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"9a0b51347cf1806a3c5870dffe83294b16325a9e46b47bba1233e7e3fb48209e","tool":"lean"} diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.lean b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.lean similarity index 100% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.lean rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.lean diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.process.json b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.process.json similarity index 71% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.process.json rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.process.json index aed476e8c..6c1e31f44 100644 --- a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.process.json +++ b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A9962d043362f4a167c67517d483f0f24.Collections.Tables","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Tables.buildTable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.callGraph' does not depend on any axioms\n'Collections.Tables.callOrder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.declare' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.reachableFromParse' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"b5887435160be7412b795a6f5a33d36ac682a409c841bd95a8d98982df4173e9","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.Collections.Tables","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Collections.Tables.buildTable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.callGraph' does not depend on any axioms\n'Collections.Tables.callOrder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.declare' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Collections.Tables.reachableFromParse' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"b5887435160be7412b795a6f5a33d36ac682a409c841bd95a8d98982df4173e9","tool":"lean"} diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.lean b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.lean rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.process.json b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.process.json similarity index 97% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.process.json rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.process.json index ab9a0c573..ca7fb4454 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.process.json +++ b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.lean b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.lean rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.lean diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.process.json b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.process.json similarity index 98% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.process.json rename to examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.process.json index 96c75ddd6..13f3bde15 100644 --- a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.process.json +++ b/examples/collections/expected/verify/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A0f6d359d50d0d086f47af2c0608b2e13.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/collections/expected/verify/probe/LexLeanProbe.P9962d043362f4a167c67517d483f0f24.lean b/examples/collections/expected/verify/probe/LexLeanProbe.P0f6d359d50d0d086f47af2c0608b2e13.lean similarity index 100% rename from examples/collections/expected/verify/probe/LexLeanProbe.P9962d043362f4a167c67517d483f0f24.lean rename to examples/collections/expected/verify/probe/LexLeanProbe.P0f6d359d50d0d086f47af2c0608b2e13.lean diff --git a/examples/collections/expected/verify/probe/process.json b/examples/collections/expected/verify/probe/process.json index 5e7a1d634..3d1d541d3 100644 --- a/examples/collections/expected/verify/probe/process.json +++ b/examples/collections/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P9962d043362f4a167c67517d483f0f24.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P9962d043362f4a167c67517d483f0f24","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P0f6d359d50d0d086f47af2c0608b2e13.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P0f6d359d50d0d086f47af2c0608b2e13","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/collections/lexlean.lock b/examples/collections/lexlean.lock index d5a2abdac..55d71299a 100644 --- a/examples/collections/lexlean.lock +++ b/examples/collections/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "87b05dc405590c51e9a51ac60ef00f9096c4a38c29b9bab379a02d5c6a1cd744" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/fold-laws/expected/build/manifest.json b/examples/fold-laws/expected/build/manifest.json index 6587df6df..1852bcb4e 100644 --- a/examples/fold-laws/expected/build/manifest.json +++ b/examples/fold-laws/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"e744465bcea2371d6d58d0d12b2feec45b3e588a941e9dbe597a8e0005a2aaf6","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1055,"kind":"lexicon","path":"glossary/folds.titles","sha256":"0f45f7e4112147980b825a8d49fce9743085673af0beb23f5819d7e4170ae8cc"},{"byte_length":1937,"kind":"lock","path":"lexlean.lock","sha256":"7cf5f545f0bd7a3a3d1c48c3e9a8e71ddd8b2bf32d8e3c31a91987861ed49c39"},{"byte_length":729,"kind":"project-config","path":"lexlean.toml","sha256":"6b4aefb16459176dc5845ec6df13b390d7105a2c9d8ccc8ce08d2bbabb4058d0"},{"byte_length":4675,"kind":"source","path":"src/Folds.lex.tex","sha256":"54564f4bf135ae9deafd8bd854fbc5c09723b85a054ae2261f19b3b137bc3598"},{"byte_length":4105,"kind":"source","path":"src/Kernels.lex.tex","sha256":"951bf028cbf1d8a95dcdddc7e9d6608e180ed697c5ea9df60b8b1c2507b7190f"},{"byte_length":2919,"kind":"source","path":"src/Main.lex.tex","sha256":"1b2a8a0757e577bf53d164171059e97b45db69e9baa1cfedd09511f03d941a59"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"FoldLaws.Folds","module":"Folds","source_path":"src/Folds.lex.tex"},{"lean_module":"FoldLaws.Kernels","module":"Kernels","source_path":"src/Kernels.lex.tex"},{"lean_module":"FoldLaws.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":13833,"kind":"coverage","path":"coverage/FoldLaws/Folds.coverage.json","sha256":"63d21e10c047710bf1325fc8271efed1ff6240d36873ea0b5e4fbbf42445eb91"},{"byte_length":12885,"kind":"coverage","path":"coverage/FoldLaws/Kernels.coverage.json","sha256":"92223c1952d44fce36580349b24c8be1a6ef5be828e06cc31d46186618b84fb5"},{"byte_length":11508,"kind":"coverage","path":"coverage/FoldLaws/Main.coverage.json","sha256":"b852d2cfc2f4500ea7af013832451ca248e81f731d08a8fe9dff4bf4db583424"},{"byte_length":27238,"kind":"lean","path":"modules/FoldLaws/Folds.lean","sha256":"ca2813622e361c44f9aee1f54bc5b17ce07f2d22bd3719da79c3ff17120ec55f"},{"byte_length":46927,"kind":"lean","path":"modules/FoldLaws/Kernels.lean","sha256":"e120b160e36d551c343d3315d79108421701b0dece4c00e812975f4dd99db001"},{"byte_length":8527,"kind":"lean","path":"modules/FoldLaws/Main.lean","sha256":"1c9a93fdd3335cd736efa668527a232c7da770c9f1fac983e9fc5fa33b8f1956"},{"byte_length":10939,"kind":"lexicon-closure","path":"lexicons/Folds.closure.json","sha256":"cc043dc592e53f7530772cc415b57c829a241e34477d41ba4bd49dd0bbead60e"},{"byte_length":10941,"kind":"lexicon-closure","path":"lexicons/Kernels.closure.json","sha256":"a5720bb307053d30157fb4b207e491e95463e36735a568226e3f11927af91f8e"},{"byte_length":10938,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"b1f4da7a53917fe7bb7857e086af159801d5d909c6cdf9edf064cfcecd599a2d"},{"byte_length":7773,"kind":"map","path":"maps/FoldLaws/Folds.map.json","sha256":"f0e8c5882d3201392beadaef1f9281f30851547acef7d4e2672470b93f922505"},{"byte_length":6519,"kind":"map","path":"maps/FoldLaws/Kernels.map.json","sha256":"3e11f296a75598e25ba9aa479263456d6c4bba2caa9e99023761b9dcc4ffaefe"},{"byte_length":3577,"kind":"map","path":"maps/FoldLaws/Main.map.json","sha256":"7d5737774f6a2226722f68f8955397ab891d1a4ec1ebd2d5696a79cdad49b49f"},{"byte_length":8799,"kind":"tex","path":"modules/FoldLaws/Folds.tex","sha256":"b286c23d9fbeed668b1da86f12d726fa3b94465a6275301cc895eb4aea0a006d"},{"byte_length":5957,"kind":"tex","path":"modules/FoldLaws/Kernels.tex","sha256":"27b7af40fc4d77c285877bbe4e7835a8f640e0e0eaa31a9dae842a9e8b18f697"},{"byte_length":3536,"kind":"tex","path":"modules/FoldLaws/Main.tex","sha256":"27fc7bc2dccb4b3ef3178f23e8690bb10809c4fa122ccfe9ec586327b54fa513"}],"project":"fold-laws","selection":["Folds","Kernels","Main"],"semantic_id":"3cc5e8a42a7c9d201fd51d5ce22fd4f8d507769c4f777aec27ead70793c63b27","source_id":"643d28fdf0ac27267ae8c7c2fb534537b5a0305161d242aa876f844aee6222d2","spec":"lexlean/build-manifest/1"} +{"build_id":"590699971512affe9527578dc000fd192708a1010294ea9c11f9d771bece9bac","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1055,"kind":"lexicon","path":"glossary/folds.titles","sha256":"0f45f7e4112147980b825a8d49fce9743085673af0beb23f5819d7e4170ae8cc"},{"byte_length":1937,"kind":"lock","path":"lexlean.lock","sha256":"24881495aac58e9d0702a0b0fabc8c7174e987e5ba94a2905594692e723a6816"},{"byte_length":729,"kind":"project-config","path":"lexlean.toml","sha256":"6b4aefb16459176dc5845ec6df13b390d7105a2c9d8ccc8ce08d2bbabb4058d0"},{"byte_length":4675,"kind":"source","path":"src/Folds.lex.tex","sha256":"54564f4bf135ae9deafd8bd854fbc5c09723b85a054ae2261f19b3b137bc3598"},{"byte_length":4105,"kind":"source","path":"src/Kernels.lex.tex","sha256":"951bf028cbf1d8a95dcdddc7e9d6608e180ed697c5ea9df60b8b1c2507b7190f"},{"byte_length":2919,"kind":"source","path":"src/Main.lex.tex","sha256":"1b2a8a0757e577bf53d164171059e97b45db69e9baa1cfedd09511f03d941a59"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"FoldLaws.Folds","module":"Folds","source_path":"src/Folds.lex.tex"},{"lean_module":"FoldLaws.Kernels","module":"Kernels","source_path":"src/Kernels.lex.tex"},{"lean_module":"FoldLaws.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":13833,"kind":"coverage","path":"coverage/FoldLaws/Folds.coverage.json","sha256":"63d21e10c047710bf1325fc8271efed1ff6240d36873ea0b5e4fbbf42445eb91"},{"byte_length":12885,"kind":"coverage","path":"coverage/FoldLaws/Kernels.coverage.json","sha256":"92223c1952d44fce36580349b24c8be1a6ef5be828e06cc31d46186618b84fb5"},{"byte_length":11508,"kind":"coverage","path":"coverage/FoldLaws/Main.coverage.json","sha256":"b852d2cfc2f4500ea7af013832451ca248e81f731d08a8fe9dff4bf4db583424"},{"byte_length":27238,"kind":"lean","path":"modules/FoldLaws/Folds.lean","sha256":"ca2813622e361c44f9aee1f54bc5b17ce07f2d22bd3719da79c3ff17120ec55f"},{"byte_length":46927,"kind":"lean","path":"modules/FoldLaws/Kernels.lean","sha256":"e120b160e36d551c343d3315d79108421701b0dece4c00e812975f4dd99db001"},{"byte_length":8527,"kind":"lean","path":"modules/FoldLaws/Main.lean","sha256":"1c9a93fdd3335cd736efa668527a232c7da770c9f1fac983e9fc5fa33b8f1956"},{"byte_length":10939,"kind":"lexicon-closure","path":"lexicons/Folds.closure.json","sha256":"cc043dc592e53f7530772cc415b57c829a241e34477d41ba4bd49dd0bbead60e"},{"byte_length":10941,"kind":"lexicon-closure","path":"lexicons/Kernels.closure.json","sha256":"a5720bb307053d30157fb4b207e491e95463e36735a568226e3f11927af91f8e"},{"byte_length":10938,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"b1f4da7a53917fe7bb7857e086af159801d5d909c6cdf9edf064cfcecd599a2d"},{"byte_length":7773,"kind":"map","path":"maps/FoldLaws/Folds.map.json","sha256":"e538dbded555072d8ad228f2ec041880bb970733869b48bf5412cd243eafc465"},{"byte_length":6519,"kind":"map","path":"maps/FoldLaws/Kernels.map.json","sha256":"1e378da694565f0eab13e0b742d2f9a9a18f1d35044e73b8a384871c274b7bde"},{"byte_length":3577,"kind":"map","path":"maps/FoldLaws/Main.map.json","sha256":"8b5e0464405f30dc407ed8be495e7eda892847633990565978b52a7c93b8dd3c"},{"byte_length":8799,"kind":"tex","path":"modules/FoldLaws/Folds.tex","sha256":"b286c23d9fbeed668b1da86f12d726fa3b94465a6275301cc895eb4aea0a006d"},{"byte_length":5957,"kind":"tex","path":"modules/FoldLaws/Kernels.tex","sha256":"27b7af40fc4d77c285877bbe4e7835a8f640e0e0eaa31a9dae842a9e8b18f697"},{"byte_length":3536,"kind":"tex","path":"modules/FoldLaws/Main.tex","sha256":"27fc7bc2dccb4b3ef3178f23e8690bb10809c4fa122ccfe9ec586327b54fa513"}],"project":"fold-laws","selection":["Folds","Kernels","Main"],"semantic_id":"1d59f84598c9f4c2cea21d972760d780f4ba88099ed49b81ffedd3f1acbf79d7","source_id":"4435dd3506d9df549955aa769eb32cb63293a6067cbbed9b94d0fc281ce7e34f","spec":"lexlean/build-manifest/1"} diff --git a/examples/fold-laws/expected/build/maps/FoldLaws/Folds.map.json b/examples/fold-laws/expected/build/maps/FoldLaws/Folds.map.json index 212ffa05c..8cbb099a9 100644 --- a/examples/fold-laws/expected/build/maps/FoldLaws/Folds.map.json +++ b/examples/fold-laws/expected/build/maps/FoldLaws/Folds.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Folds.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Folds.tex"}],"mappings":[{"artifact":0,"gen_end":310,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":0,"gen_end":453,"gen_start":310,"node":1,"role":"declaration","source":0,"src_end":312,"src_start":139},{"artifact":0,"gen_end":597,"gen_start":453,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":314},{"artifact":0,"gen_end":753,"gen_start":597,"node":3,"role":"declaration","source":0,"src_end":675,"src_start":489},{"artifact":0,"gen_end":943,"gen_start":753,"node":4,"role":"declaration","source":0,"src_end":883,"src_start":677},{"artifact":0,"gen_end":1127,"gen_start":943,"node":5,"role":"declaration","source":0,"src_end":1093,"src_start":885},{"artifact":0,"gen_end":1340,"gen_start":1127,"node":6,"role":"declaration","source":0,"src_end":1323,"src_start":1095},{"artifact":0,"gen_end":1584,"gen_start":1340,"node":7,"role":"declaration","source":0,"src_end":1572,"src_start":1325},{"artifact":0,"gen_end":1727,"gen_start":1584,"node":8,"role":"declaration","source":0,"src_end":1746,"src_start":1574},{"artifact":0,"gen_end":1910,"gen_start":1727,"node":9,"role":"declaration","source":0,"src_end":1946,"src_start":1748},{"artifact":0,"gen_end":2084,"gen_start":1910,"node":10,"role":"declaration","source":0,"src_end":2142,"src_start":1948},{"artifact":0,"gen_end":2251,"gen_start":2084,"node":11,"role":"declaration","source":0,"src_end":2330,"src_start":2144},{"artifact":0,"gen_end":2420,"gen_start":2251,"node":12,"role":"declaration","source":0,"src_end":2520,"src_start":2332},{"artifact":0,"gen_end":5473,"gen_start":2420,"node":13,"role":"declaration","source":0,"src_end":2746,"src_start":2522},{"artifact":0,"gen_end":8516,"gen_start":5473,"node":14,"role":"declaration","source":0,"src_end":2950,"src_start":2748},{"artifact":0,"gen_end":11607,"gen_start":8516,"node":15,"role":"declaration","source":0,"src_end":3200,"src_start":2952},{"artifact":0,"gen_end":14738,"gen_start":11607,"node":16,"role":"declaration","source":0,"src_end":3475,"src_start":3202},{"artifact":0,"gen_end":17777,"gen_start":14738,"node":17,"role":"declaration","source":0,"src_end":3687,"src_start":3477},{"artifact":0,"gen_end":20953,"gen_start":17777,"node":18,"role":"declaration","source":0,"src_end":4003,"src_start":3689},{"artifact":0,"gen_end":24026,"gen_start":20953,"node":19,"role":"declaration","source":0,"src_end":4234,"src_start":4005},{"artifact":0,"gen_end":27103,"gen_start":24026,"node":20,"role":"declaration","source":0,"src_end":4474,"src_start":4236},{"artifact":0,"gen_end":27218,"gen_start":27103,"node":21,"role":"declaration","source":0,"src_end":4639,"src_start":4476},{"artifact":0,"gen_end":27238,"gen_start":27218,"node":0,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":22,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":1,"gen_end":596,"gen_start":134,"node":23,"role":"declaration","source":0,"src_end":312,"src_start":139},{"artifact":1,"gen_end":1060,"gen_start":596,"node":24,"role":"declaration","source":0,"src_end":487,"src_start":314},{"artifact":1,"gen_end":1535,"gen_start":1060,"node":25,"role":"declaration","source":0,"src_end":675,"src_start":489},{"artifact":1,"gen_end":2044,"gen_start":1535,"node":26,"role":"declaration","source":0,"src_end":883,"src_start":677},{"artifact":1,"gen_end":2547,"gen_start":2044,"node":27,"role":"declaration","source":0,"src_end":1093,"src_start":885},{"artifact":1,"gen_end":3079,"gen_start":2547,"node":28,"role":"declaration","source":0,"src_end":1323,"src_start":1095},{"artifact":1,"gen_end":3642,"gen_start":3079,"node":29,"role":"declaration","source":0,"src_end":1572,"src_start":1325},{"artifact":1,"gen_end":4103,"gen_start":3642,"node":30,"role":"declaration","source":0,"src_end":1746,"src_start":1574},{"artifact":1,"gen_end":4604,"gen_start":4103,"node":31,"role":"declaration","source":0,"src_end":1946,"src_start":1748},{"artifact":1,"gen_end":5092,"gen_start":4604,"node":32,"role":"declaration","source":0,"src_end":2142,"src_start":1948},{"artifact":1,"gen_end":5574,"gen_start":5092,"node":33,"role":"declaration","source":0,"src_end":2330,"src_start":2144},{"artifact":1,"gen_end":6058,"gen_start":5574,"node":34,"role":"declaration","source":0,"src_end":2520,"src_start":2332},{"artifact":1,"gen_end":6337,"gen_start":6058,"node":35,"role":"declaration","source":0,"src_end":2746,"src_start":2522},{"artifact":1,"gen_end":6621,"gen_start":6337,"node":36,"role":"declaration","source":0,"src_end":2950,"src_start":2748},{"artifact":1,"gen_end":6935,"gen_start":6621,"node":37,"role":"declaration","source":0,"src_end":3200,"src_start":2952},{"artifact":1,"gen_end":7307,"gen_start":6935,"node":38,"role":"declaration","source":0,"src_end":3475,"src_start":3202},{"artifact":1,"gen_end":7576,"gen_start":7307,"node":39,"role":"declaration","source":0,"src_end":3687,"src_start":3477},{"artifact":1,"gen_end":7982,"gen_start":7576,"node":40,"role":"declaration","source":0,"src_end":4003,"src_start":3689},{"artifact":1,"gen_end":8279,"gen_start":7982,"node":41,"role":"declaration","source":0,"src_end":4234,"src_start":4005},{"artifact":1,"gen_end":8561,"gen_start":8279,"node":42,"role":"declaration","source":0,"src_end":4474,"src_start":4236},{"artifact":1,"gen_end":8784,"gen_start":8561,"node":43,"role":"declaration","source":0,"src_end":4639,"src_start":4476},{"artifact":1,"gen_end":8799,"gen_start":8784,"node":22,"role":"declaration","source":0,"src_end":4675,"src_start":0}],"module":"Folds","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-latex-module"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"}],"semantic_id":"3cc5e8a42a7c9d201fd51d5ce22fd4f8d507769c4f777aec27ead70793c63b27","source_id":"643d28fdf0ac27267ae8c7c2fb534537b5a0305161d242aa876f844aee6222d2","sources":[{"id":0,"kind":"file","path":"src/Folds.lex.tex","sha256":"54564f4bf135ae9deafd8bd854fbc5c09723b85a054ae2261f19b3b137bc3598"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Folds.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Folds.tex"}],"mappings":[{"artifact":0,"gen_end":310,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":0,"gen_end":453,"gen_start":310,"node":1,"role":"declaration","source":0,"src_end":312,"src_start":139},{"artifact":0,"gen_end":597,"gen_start":453,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":314},{"artifact":0,"gen_end":753,"gen_start":597,"node":3,"role":"declaration","source":0,"src_end":675,"src_start":489},{"artifact":0,"gen_end":943,"gen_start":753,"node":4,"role":"declaration","source":0,"src_end":883,"src_start":677},{"artifact":0,"gen_end":1127,"gen_start":943,"node":5,"role":"declaration","source":0,"src_end":1093,"src_start":885},{"artifact":0,"gen_end":1340,"gen_start":1127,"node":6,"role":"declaration","source":0,"src_end":1323,"src_start":1095},{"artifact":0,"gen_end":1584,"gen_start":1340,"node":7,"role":"declaration","source":0,"src_end":1572,"src_start":1325},{"artifact":0,"gen_end":1727,"gen_start":1584,"node":8,"role":"declaration","source":0,"src_end":1746,"src_start":1574},{"artifact":0,"gen_end":1910,"gen_start":1727,"node":9,"role":"declaration","source":0,"src_end":1946,"src_start":1748},{"artifact":0,"gen_end":2084,"gen_start":1910,"node":10,"role":"declaration","source":0,"src_end":2142,"src_start":1948},{"artifact":0,"gen_end":2251,"gen_start":2084,"node":11,"role":"declaration","source":0,"src_end":2330,"src_start":2144},{"artifact":0,"gen_end":2420,"gen_start":2251,"node":12,"role":"declaration","source":0,"src_end":2520,"src_start":2332},{"artifact":0,"gen_end":5473,"gen_start":2420,"node":13,"role":"declaration","source":0,"src_end":2746,"src_start":2522},{"artifact":0,"gen_end":8516,"gen_start":5473,"node":14,"role":"declaration","source":0,"src_end":2950,"src_start":2748},{"artifact":0,"gen_end":11607,"gen_start":8516,"node":15,"role":"declaration","source":0,"src_end":3200,"src_start":2952},{"artifact":0,"gen_end":14738,"gen_start":11607,"node":16,"role":"declaration","source":0,"src_end":3475,"src_start":3202},{"artifact":0,"gen_end":17777,"gen_start":14738,"node":17,"role":"declaration","source":0,"src_end":3687,"src_start":3477},{"artifact":0,"gen_end":20953,"gen_start":17777,"node":18,"role":"declaration","source":0,"src_end":4003,"src_start":3689},{"artifact":0,"gen_end":24026,"gen_start":20953,"node":19,"role":"declaration","source":0,"src_end":4234,"src_start":4005},{"artifact":0,"gen_end":27103,"gen_start":24026,"node":20,"role":"declaration","source":0,"src_end":4474,"src_start":4236},{"artifact":0,"gen_end":27218,"gen_start":27103,"node":21,"role":"declaration","source":0,"src_end":4639,"src_start":4476},{"artifact":0,"gen_end":27238,"gen_start":27218,"node":0,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":22,"role":"declaration","source":0,"src_end":4675,"src_start":0},{"artifact":1,"gen_end":596,"gen_start":134,"node":23,"role":"declaration","source":0,"src_end":312,"src_start":139},{"artifact":1,"gen_end":1060,"gen_start":596,"node":24,"role":"declaration","source":0,"src_end":487,"src_start":314},{"artifact":1,"gen_end":1535,"gen_start":1060,"node":25,"role":"declaration","source":0,"src_end":675,"src_start":489},{"artifact":1,"gen_end":2044,"gen_start":1535,"node":26,"role":"declaration","source":0,"src_end":883,"src_start":677},{"artifact":1,"gen_end":2547,"gen_start":2044,"node":27,"role":"declaration","source":0,"src_end":1093,"src_start":885},{"artifact":1,"gen_end":3079,"gen_start":2547,"node":28,"role":"declaration","source":0,"src_end":1323,"src_start":1095},{"artifact":1,"gen_end":3642,"gen_start":3079,"node":29,"role":"declaration","source":0,"src_end":1572,"src_start":1325},{"artifact":1,"gen_end":4103,"gen_start":3642,"node":30,"role":"declaration","source":0,"src_end":1746,"src_start":1574},{"artifact":1,"gen_end":4604,"gen_start":4103,"node":31,"role":"declaration","source":0,"src_end":1946,"src_start":1748},{"artifact":1,"gen_end":5092,"gen_start":4604,"node":32,"role":"declaration","source":0,"src_end":2142,"src_start":1948},{"artifact":1,"gen_end":5574,"gen_start":5092,"node":33,"role":"declaration","source":0,"src_end":2330,"src_start":2144},{"artifact":1,"gen_end":6058,"gen_start":5574,"node":34,"role":"declaration","source":0,"src_end":2520,"src_start":2332},{"artifact":1,"gen_end":6337,"gen_start":6058,"node":35,"role":"declaration","source":0,"src_end":2746,"src_start":2522},{"artifact":1,"gen_end":6621,"gen_start":6337,"node":36,"role":"declaration","source":0,"src_end":2950,"src_start":2748},{"artifact":1,"gen_end":6935,"gen_start":6621,"node":37,"role":"declaration","source":0,"src_end":3200,"src_start":2952},{"artifact":1,"gen_end":7307,"gen_start":6935,"node":38,"role":"declaration","source":0,"src_end":3475,"src_start":3202},{"artifact":1,"gen_end":7576,"gen_start":7307,"node":39,"role":"declaration","source":0,"src_end":3687,"src_start":3477},{"artifact":1,"gen_end":7982,"gen_start":7576,"node":40,"role":"declaration","source":0,"src_end":4003,"src_start":3689},{"artifact":1,"gen_end":8279,"gen_start":7982,"node":41,"role":"declaration","source":0,"src_end":4234,"src_start":4005},{"artifact":1,"gen_end":8561,"gen_start":8279,"node":42,"role":"declaration","source":0,"src_end":4474,"src_start":4236},{"artifact":1,"gen_end":8784,"gen_start":8561,"node":43,"role":"declaration","source":0,"src_end":4639,"src_start":4476},{"artifact":1,"gen_end":8799,"gen_start":8784,"node":22,"role":"declaration","source":0,"src_end":4675,"src_start":0}],"module":"Folds","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-latex-module"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"}],"semantic_id":"1d59f84598c9f4c2cea21d972760d780f4ba88099ed49b81ffedd3f1acbf79d7","source_id":"4435dd3506d9df549955aa769eb32cb63293a6067cbbed9b94d0fc281ce7e34f","sources":[{"id":0,"kind":"file","path":"src/Folds.lex.tex","sha256":"54564f4bf135ae9deafd8bd854fbc5c09723b85a054ae2261f19b3b137bc3598"}],"spec":"lexlean/source-map/1"} diff --git a/examples/fold-laws/expected/build/maps/FoldLaws/Kernels.map.json b/examples/fold-laws/expected/build/maps/FoldLaws/Kernels.map.json index 6a540252b..64979156b 100644 --- a/examples/fold-laws/expected/build/maps/FoldLaws/Kernels.map.json +++ b/examples/fold-laws/expected/build/maps/FoldLaws/Kernels.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Kernels.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Kernels.tex"}],"mappings":[{"artifact":0,"gen_end":312,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":0,"gen_end":769,"gen_start":312,"node":1,"role":"declaration","source":0,"src_end":576,"src_start":141},{"artifact":0,"gen_end":3822,"gen_start":769,"node":2,"role":"declaration","source":0,"src_end":801,"src_start":578},{"artifact":0,"gen_end":6975,"gen_start":3822,"node":3,"role":"declaration","source":0,"src_end":1092,"src_start":803},{"artifact":0,"gen_end":9994,"gen_start":6975,"node":4,"role":"declaration","source":0,"src_end":1284,"src_start":1094},{"artifact":0,"gen_end":13016,"gen_start":9994,"node":5,"role":"declaration","source":0,"src_end":1479,"src_start":1286},{"artifact":0,"gen_end":16226,"gen_start":13016,"node":6,"role":"declaration","source":0,"src_end":1790,"src_start":1481},{"artifact":0,"gen_end":19448,"gen_start":16226,"node":7,"role":"declaration","source":0,"src_end":2113,"src_start":1792},{"artifact":0,"gen_end":22609,"gen_start":19448,"node":8,"role":"declaration","source":0,"src_end":2397,"src_start":2115},{"artifact":0,"gen_end":25643,"gen_start":22609,"node":9,"role":"declaration","source":0,"src_end":2587,"src_start":2399},{"artifact":0,"gen_end":28659,"gen_start":25643,"node":10,"role":"declaration","source":0,"src_end":2760,"src_start":2589},{"artifact":0,"gen_end":31680,"gen_start":28659,"node":11,"role":"declaration","source":0,"src_end":2952,"src_start":2762},{"artifact":0,"gen_end":34665,"gen_start":31680,"node":12,"role":"declaration","source":0,"src_end":3110,"src_start":2954},{"artifact":0,"gen_end":37671,"gen_start":34665,"node":13,"role":"declaration","source":0,"src_end":3289,"src_start":3112},{"artifact":0,"gen_end":40717,"gen_start":37671,"node":14,"role":"declaration","source":0,"src_end":3490,"src_start":3291},{"artifact":0,"gen_end":43777,"gen_start":40717,"node":15,"role":"declaration","source":0,"src_end":3724,"src_start":3492},{"artifact":0,"gen_end":46815,"gen_start":43777,"node":16,"role":"declaration","source":0,"src_end":3920,"src_start":3726},{"artifact":0,"gen_end":46905,"gen_start":46815,"node":17,"role":"declaration","source":0,"src_end":4069,"src_start":3922},{"artifact":0,"gen_end":46927,"gen_start":46905,"node":0,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":18,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":1,"gen_end":849,"gen_start":134,"node":19,"role":"declaration","source":0,"src_end":576,"src_start":141},{"artifact":1,"gen_end":1137,"gen_start":849,"node":20,"role":"declaration","source":0,"src_end":801,"src_start":578},{"artifact":1,"gen_end":1526,"gen_start":1137,"node":21,"role":"declaration","source":0,"src_end":1092,"src_start":803},{"artifact":1,"gen_end":1780,"gen_start":1526,"node":22,"role":"declaration","source":0,"src_end":1284,"src_start":1094},{"artifact":1,"gen_end":2037,"gen_start":1780,"node":23,"role":"declaration","source":0,"src_end":1479,"src_start":1286},{"artifact":1,"gen_end":2507,"gen_start":2037,"node":24,"role":"declaration","source":0,"src_end":1790,"src_start":1481},{"artifact":1,"gen_end":2990,"gen_start":2507,"node":25,"role":"declaration","source":0,"src_end":2113,"src_start":1792},{"artifact":1,"gen_end":3412,"gen_start":2990,"node":26,"role":"declaration","source":0,"src_end":2397,"src_start":2115},{"artifact":1,"gen_end":3707,"gen_start":3412,"node":27,"role":"declaration","source":0,"src_end":2587,"src_start":2399},{"artifact":1,"gen_end":3983,"gen_start":3707,"node":28,"role":"declaration","source":0,"src_end":2760,"src_start":2589},{"artifact":1,"gen_end":4264,"gen_start":3983,"node":29,"role":"declaration","source":0,"src_end":2952,"src_start":2762},{"artifact":1,"gen_end":4509,"gen_start":4264,"node":30,"role":"declaration","source":0,"src_end":3110,"src_start":2954},{"artifact":1,"gen_end":4775,"gen_start":4509,"node":31,"role":"declaration","source":0,"src_end":3289,"src_start":3112},{"artifact":1,"gen_end":5082,"gen_start":4775,"node":32,"role":"declaration","source":0,"src_end":3490,"src_start":3291},{"artifact":1,"gen_end":5436,"gen_start":5082,"node":33,"role":"declaration","source":0,"src_end":3724,"src_start":3492},{"artifact":1,"gen_end":5734,"gen_start":5436,"node":34,"role":"declaration","source":0,"src_end":3920,"src_start":3726},{"artifact":1,"gen_end":5942,"gen_start":5734,"node":35,"role":"declaration","source":0,"src_end":4069,"src_start":3922},{"artifact":1,"gen_end":5957,"gen_start":5942,"node":18,"role":"declaration","source":0,"src_end":4105,"src_start":0}],"module":"Kernels","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-latex-module"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"}],"semantic_id":"3cc5e8a42a7c9d201fd51d5ce22fd4f8d507769c4f777aec27ead70793c63b27","source_id":"643d28fdf0ac27267ae8c7c2fb534537b5a0305161d242aa876f844aee6222d2","sources":[{"id":0,"kind":"file","path":"src/Kernels.lex.tex","sha256":"951bf028cbf1d8a95dcdddc7e9d6608e180ed697c5ea9df60b8b1c2507b7190f"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Kernels.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Kernels.tex"}],"mappings":[{"artifact":0,"gen_end":312,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":0,"gen_end":769,"gen_start":312,"node":1,"role":"declaration","source":0,"src_end":576,"src_start":141},{"artifact":0,"gen_end":3822,"gen_start":769,"node":2,"role":"declaration","source":0,"src_end":801,"src_start":578},{"artifact":0,"gen_end":6975,"gen_start":3822,"node":3,"role":"declaration","source":0,"src_end":1092,"src_start":803},{"artifact":0,"gen_end":9994,"gen_start":6975,"node":4,"role":"declaration","source":0,"src_end":1284,"src_start":1094},{"artifact":0,"gen_end":13016,"gen_start":9994,"node":5,"role":"declaration","source":0,"src_end":1479,"src_start":1286},{"artifact":0,"gen_end":16226,"gen_start":13016,"node":6,"role":"declaration","source":0,"src_end":1790,"src_start":1481},{"artifact":0,"gen_end":19448,"gen_start":16226,"node":7,"role":"declaration","source":0,"src_end":2113,"src_start":1792},{"artifact":0,"gen_end":22609,"gen_start":19448,"node":8,"role":"declaration","source":0,"src_end":2397,"src_start":2115},{"artifact":0,"gen_end":25643,"gen_start":22609,"node":9,"role":"declaration","source":0,"src_end":2587,"src_start":2399},{"artifact":0,"gen_end":28659,"gen_start":25643,"node":10,"role":"declaration","source":0,"src_end":2760,"src_start":2589},{"artifact":0,"gen_end":31680,"gen_start":28659,"node":11,"role":"declaration","source":0,"src_end":2952,"src_start":2762},{"artifact":0,"gen_end":34665,"gen_start":31680,"node":12,"role":"declaration","source":0,"src_end":3110,"src_start":2954},{"artifact":0,"gen_end":37671,"gen_start":34665,"node":13,"role":"declaration","source":0,"src_end":3289,"src_start":3112},{"artifact":0,"gen_end":40717,"gen_start":37671,"node":14,"role":"declaration","source":0,"src_end":3490,"src_start":3291},{"artifact":0,"gen_end":43777,"gen_start":40717,"node":15,"role":"declaration","source":0,"src_end":3724,"src_start":3492},{"artifact":0,"gen_end":46815,"gen_start":43777,"node":16,"role":"declaration","source":0,"src_end":3920,"src_start":3726},{"artifact":0,"gen_end":46905,"gen_start":46815,"node":17,"role":"declaration","source":0,"src_end":4069,"src_start":3922},{"artifact":0,"gen_end":46927,"gen_start":46905,"node":0,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":18,"role":"declaration","source":0,"src_end":4105,"src_start":0},{"artifact":1,"gen_end":849,"gen_start":134,"node":19,"role":"declaration","source":0,"src_end":576,"src_start":141},{"artifact":1,"gen_end":1137,"gen_start":849,"node":20,"role":"declaration","source":0,"src_end":801,"src_start":578},{"artifact":1,"gen_end":1526,"gen_start":1137,"node":21,"role":"declaration","source":0,"src_end":1092,"src_start":803},{"artifact":1,"gen_end":1780,"gen_start":1526,"node":22,"role":"declaration","source":0,"src_end":1284,"src_start":1094},{"artifact":1,"gen_end":2037,"gen_start":1780,"node":23,"role":"declaration","source":0,"src_end":1479,"src_start":1286},{"artifact":1,"gen_end":2507,"gen_start":2037,"node":24,"role":"declaration","source":0,"src_end":1790,"src_start":1481},{"artifact":1,"gen_end":2990,"gen_start":2507,"node":25,"role":"declaration","source":0,"src_end":2113,"src_start":1792},{"artifact":1,"gen_end":3412,"gen_start":2990,"node":26,"role":"declaration","source":0,"src_end":2397,"src_start":2115},{"artifact":1,"gen_end":3707,"gen_start":3412,"node":27,"role":"declaration","source":0,"src_end":2587,"src_start":2399},{"artifact":1,"gen_end":3983,"gen_start":3707,"node":28,"role":"declaration","source":0,"src_end":2760,"src_start":2589},{"artifact":1,"gen_end":4264,"gen_start":3983,"node":29,"role":"declaration","source":0,"src_end":2952,"src_start":2762},{"artifact":1,"gen_end":4509,"gen_start":4264,"node":30,"role":"declaration","source":0,"src_end":3110,"src_start":2954},{"artifact":1,"gen_end":4775,"gen_start":4509,"node":31,"role":"declaration","source":0,"src_end":3289,"src_start":3112},{"artifact":1,"gen_end":5082,"gen_start":4775,"node":32,"role":"declaration","source":0,"src_end":3490,"src_start":3291},{"artifact":1,"gen_end":5436,"gen_start":5082,"node":33,"role":"declaration","source":0,"src_end":3724,"src_start":3492},{"artifact":1,"gen_end":5734,"gen_start":5436,"node":34,"role":"declaration","source":0,"src_end":3920,"src_start":3726},{"artifact":1,"gen_end":5942,"gen_start":5734,"node":35,"role":"declaration","source":0,"src_end":4069,"src_start":3922},{"artifact":1,"gen_end":5957,"gen_start":5942,"node":18,"role":"declaration","source":0,"src_end":4105,"src_start":0}],"module":"Kernels","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-latex-module"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"}],"semantic_id":"1d59f84598c9f4c2cea21d972760d780f4ba88099ed49b81ffedd3f1acbf79d7","source_id":"4435dd3506d9df549955aa769eb32cb63293a6067cbbed9b94d0fc281ce7e34f","sources":[{"id":0,"kind":"file","path":"src/Kernels.lex.tex","sha256":"951bf028cbf1d8a95dcdddc7e9d6608e180ed697c5ea9df60b8b1c2507b7190f"}],"spec":"lexlean/source-map/1"} diff --git a/examples/fold-laws/expected/build/maps/FoldLaws/Main.map.json b/examples/fold-laws/expected/build/maps/FoldLaws/Main.map.json index fa6c2ad1a..58b7e2194 100644 --- a/examples/fold-laws/expected/build/maps/FoldLaws/Main.map.json +++ b/examples/fold-laws/expected/build/maps/FoldLaws/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Main.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Main.tex"}],"mappings":[{"artifact":0,"gen_end":369,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":0,"gen_end":582,"gen_start":369,"node":1,"role":"declaration","source":0,"src_end":427,"src_start":196},{"artifact":0,"gen_end":872,"gen_start":582,"node":2,"role":"declaration","source":0,"src_end":815,"src_start":429},{"artifact":0,"gen_end":1059,"gen_start":872,"node":3,"role":"declaration","source":0,"src_end":1018,"src_start":817},{"artifact":0,"gen_end":4179,"gen_start":1059,"node":4,"role":"declaration","source":0,"src_end":1262,"src_start":1020},{"artifact":0,"gen_end":4752,"gen_start":4179,"node":5,"role":"declaration","source":0,"src_end":1879,"src_start":1264},{"artifact":0,"gen_end":4921,"gen_start":4752,"node":6,"role":"declaration","source":0,"src_end":2112,"src_start":1881},{"artifact":0,"gen_end":5288,"gen_start":4921,"node":7,"role":"declaration","source":0,"src_end":2527,"src_start":2114},{"artifact":0,"gen_end":8508,"gen_start":5288,"node":8,"role":"declaration","source":0,"src_end":2883,"src_start":2529},{"artifact":0,"gen_end":8527,"gen_start":8508,"node":0,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":1,"gen_end":664,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":427,"src_start":196},{"artifact":1,"gen_end":954,"gen_start":664,"node":11,"role":"declaration","source":0,"src_end":815,"src_start":429},{"artifact":1,"gen_end":1460,"gen_start":954,"node":12,"role":"declaration","source":0,"src_end":1018,"src_start":817},{"artifact":1,"gen_end":1840,"gen_start":1460,"node":13,"role":"declaration","source":0,"src_end":1262,"src_start":1020},{"artifact":1,"gen_end":2317,"gen_start":1840,"node":14,"role":"declaration","source":0,"src_end":1879,"src_start":1264},{"artifact":1,"gen_end":2636,"gen_start":2317,"node":15,"role":"declaration","source":0,"src_end":2112,"src_start":1881},{"artifact":1,"gen_end":3072,"gen_start":2636,"node":16,"role":"declaration","source":0,"src_end":2527,"src_start":2114},{"artifact":1,"gen_end":3521,"gen_start":3072,"node":17,"role":"declaration","source":0,"src_end":2883,"src_start":2529},{"artifact":1,"gen_end":3536,"gen_start":3521,"node":9,"role":"declaration","source":0,"src_end":2919,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"3cc5e8a42a7c9d201fd51d5ce22fd4f8d507769c4f777aec27ead70793c63b27","source_id":"643d28fdf0ac27267ae8c7c2fb534537b5a0305161d242aa876f844aee6222d2","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"1b2a8a0757e577bf53d164171059e97b45db69e9baa1cfedd09511f03d941a59"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/FoldLaws/Main.lean"},{"id":1,"kind":"tex","path":"modules/FoldLaws/Main.tex"}],"mappings":[{"artifact":0,"gen_end":369,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":0,"gen_end":582,"gen_start":369,"node":1,"role":"declaration","source":0,"src_end":427,"src_start":196},{"artifact":0,"gen_end":872,"gen_start":582,"node":2,"role":"declaration","source":0,"src_end":815,"src_start":429},{"artifact":0,"gen_end":1059,"gen_start":872,"node":3,"role":"declaration","source":0,"src_end":1018,"src_start":817},{"artifact":0,"gen_end":4179,"gen_start":1059,"node":4,"role":"declaration","source":0,"src_end":1262,"src_start":1020},{"artifact":0,"gen_end":4752,"gen_start":4179,"node":5,"role":"declaration","source":0,"src_end":1879,"src_start":1264},{"artifact":0,"gen_end":4921,"gen_start":4752,"node":6,"role":"declaration","source":0,"src_end":2112,"src_start":1881},{"artifact":0,"gen_end":5288,"gen_start":4921,"node":7,"role":"declaration","source":0,"src_end":2527,"src_start":2114},{"artifact":0,"gen_end":8508,"gen_start":5288,"node":8,"role":"declaration","source":0,"src_end":2883,"src_start":2529},{"artifact":0,"gen_end":8527,"gen_start":8508,"node":0,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":2919,"src_start":0},{"artifact":1,"gen_end":664,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":427,"src_start":196},{"artifact":1,"gen_end":954,"gen_start":664,"node":11,"role":"declaration","source":0,"src_end":815,"src_start":429},{"artifact":1,"gen_end":1460,"gen_start":954,"node":12,"role":"declaration","source":0,"src_end":1018,"src_start":817},{"artifact":1,"gen_end":1840,"gen_start":1460,"node":13,"role":"declaration","source":0,"src_end":1262,"src_start":1020},{"artifact":1,"gen_end":2317,"gen_start":1840,"node":14,"role":"declaration","source":0,"src_end":1879,"src_start":1264},{"artifact":1,"gen_end":2636,"gen_start":2317,"node":15,"role":"declaration","source":0,"src_end":2112,"src_start":1881},{"artifact":1,"gen_end":3072,"gen_start":2636,"node":16,"role":"declaration","source":0,"src_end":2527,"src_start":2114},{"artifact":1,"gen_end":3521,"gen_start":3072,"node":17,"role":"declaration","source":0,"src_end":2883,"src_start":2529},{"artifact":1,"gen_end":3536,"gen_start":3521,"node":9,"role":"declaration","source":0,"src_end":2919,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"1d59f84598c9f4c2cea21d972760d780f4ba88099ed49b81ffedd3f1acbf79d7","source_id":"4435dd3506d9df549955aa769eb32cb63293a6067cbbed9b94d0fc281ce7e34f","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"1b2a8a0757e577bf53d164171059e97b45db69e9baa1cfedd09511f03d941a59"}],"spec":"lexlean/source-map/1"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.process.json similarity index 85% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.process.json index 70da9cfb4..275c064ad 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Folds","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Folds.balance' does not depend on any axioms\n'FoldLaws.Folds.balance_credit' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.count' does not depend on any axioms\n'FoldLaws.Folds.count_is_length' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.credit' does not depend on any axioms\n'FoldLaws.Folds.doubledTotal' does not depend on any axioms\n'FoldLaws.Folds.doubled_total' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.doubled_total_closed' does not depend on any axioms\n'FoldLaws.Folds.entryTotal' does not depend on any axioms\n'FoldLaws.Folds.keyTotal' does not depend on any axioms\n'FoldLaws.Folds.map_split' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.reversed' does not depend on any axioms\n'FoldLaws.Folds.setDoubled' does not depend on any axioms\n'FoldLaws.Folds.setTotal' does not depend on any axioms\n'FoldLaws.Folds.set_doubled' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.total' does not depend on any axioms\n'FoldLaws.Folds.total_append_commutes' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.total_reversed' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.valueTotal' does not depend on any axioms\n'FoldLaws.Folds.weighted' does not depend on any axioms\n'FoldLaws.Folds.weighted_total' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"a4ea8f3cb685d7641c55877667545b867aa7403287fe0cbb81eac6a43b056506","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Folds","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Folds.balance' does not depend on any axioms\n'FoldLaws.Folds.balance_credit' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.count' does not depend on any axioms\n'FoldLaws.Folds.count_is_length' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.credit' does not depend on any axioms\n'FoldLaws.Folds.doubledTotal' does not depend on any axioms\n'FoldLaws.Folds.doubled_total' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.doubled_total_closed' does not depend on any axioms\n'FoldLaws.Folds.entryTotal' does not depend on any axioms\n'FoldLaws.Folds.keyTotal' does not depend on any axioms\n'FoldLaws.Folds.map_split' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.reversed' does not depend on any axioms\n'FoldLaws.Folds.setDoubled' does not depend on any axioms\n'FoldLaws.Folds.setTotal' does not depend on any axioms\n'FoldLaws.Folds.set_doubled' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.total' does not depend on any axioms\n'FoldLaws.Folds.total_append_commutes' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.total_reversed' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Folds.valueTotal' does not depend on any axioms\n'FoldLaws.Folds.weighted' does not depend on any axioms\n'FoldLaws.Folds.weighted_total' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"a4ea8f3cb685d7641c55877667545b867aa7403287fe0cbb81eac6a43b056506","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.process.json similarity index 85% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.process.json index f67e88121..9056c6ff2 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Kernels","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Kernels.byte_ceiling' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_equality' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_literal' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_order' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.division_by_zero' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.halving_shrinks' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize' depends on axioms: [propext]\n'FoldLaws.Kernels.requantize_closed' depends on axioms: [propext]\n'FoldLaws.Kernels.requantize_high' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_low' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_monotone' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_runtime_monotone' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.signed_byte_floor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'FoldLaws.Kernels.signed_byte_order' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncating_division' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncating_division_negative' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncation_toward_zero' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"9c2786735b0465a160f39ed65373181ac6dd6bfb42059e3dea28559c3548b286","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Kernels","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Kernels.byte_ceiling' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_equality' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_literal' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.byte_order' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.division_by_zero' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.halving_shrinks' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize' depends on axioms: [propext]\n'FoldLaws.Kernels.requantize_closed' depends on axioms: [propext]\n'FoldLaws.Kernels.requantize_high' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_low' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_monotone' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.requantize_runtime_monotone' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.signed_byte_floor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'FoldLaws.Kernels.signed_byte_order' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncating_division' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncating_division_negative' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Kernels.truncation_toward_zero' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"9c2786735b0465a160f39ed65373181ac6dd6bfb42059e3dea28559c3548b286","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.process.json similarity index 74% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.process.json index eee62dcb6..61e5e6ccb 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.FoldLaws.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Main.count_append' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity' does not depend on any axioms\n'FoldLaws.Main.parity_fused' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity_of_total' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity_step' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.requantized_total' depends on axioms: [propext, Classical.choice, Quot.sound]\n'FoldLaws.Main.statistics' does not depend on any axioms\n'FoldLaws.Main.statistics_one_pass' does not depend on any axioms\n","stdout_sha256":"2652bf9be8931830e86bc7c942d488e4ad691681729b6203eed87d39cb027f07","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.FoldLaws.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'FoldLaws.Main.count_append' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity' does not depend on any axioms\n'FoldLaws.Main.parity_fused' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity_of_total' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.parity_step' depends on axioms: [propext, Quot.sound]\n'FoldLaws.Main.requantized_total' depends on axioms: [propext, Classical.choice, Quot.sound]\n'FoldLaws.Main.statistics' does not depend on any axioms\n'FoldLaws.Main.statistics_one_pass' does not depend on any axioms\n","stdout_sha256":"2652bf9be8931830e86bc7c942d488e4ad691681729b6203eed87d39cb027f07","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Collections.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.process.json similarity index 97% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.process.json index fc3520530..5dad67779 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.process.json similarity index 95% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.process.json index e3812b90a..0cf794c28 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.lean b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.lean rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.lean diff --git a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.process.json b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.process.json similarity index 98% rename from examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.process.json rename to examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.process.json index d1cd9b0bb..76e7a4edc 100644 --- a/examples/fold-laws/expected/verify/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.process.json +++ b/examples/fold-laws/expected/verify/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A3cc5e8a42a7c9d201fd51d5ce22fd4f8.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A1d59f84598c9f4c2cea21d972760d780.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/fold-laws/expected/verify/probe/LexLeanProbe.P3cc5e8a42a7c9d201fd51d5ce22fd4f8.lean b/examples/fold-laws/expected/verify/probe/LexLeanProbe.P1d59f84598c9f4c2cea21d972760d780.lean similarity index 100% rename from examples/fold-laws/expected/verify/probe/LexLeanProbe.P3cc5e8a42a7c9d201fd51d5ce22fd4f8.lean rename to examples/fold-laws/expected/verify/probe/LexLeanProbe.P1d59f84598c9f4c2cea21d972760d780.lean diff --git a/examples/fold-laws/expected/verify/probe/process.json b/examples/fold-laws/expected/verify/probe/process.json index a80a80952..315331aa6 100644 --- a/examples/fold-laws/expected/verify/probe/process.json +++ b/examples/fold-laws/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P3cc5e8a42a7c9d201fd51d5ce22fd4f8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P3cc5e8a42a7c9d201fd51d5ce22fd4f8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P1d59f84598c9f4c2cea21d972760d780.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P1d59f84598c9f4c2cea21d972760d780","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/fold-laws/lexlean.lock b/examples/fold-laws/lexlean.lock index 917cecf91..d4049844d 100644 --- a/examples/fold-laws/lexlean.lock +++ b/examples/fold-laws/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6b4aefb16459176dc5845ec6df13b390d7105a2c9d8ccc8ce08d2bbabb4058d0" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/higher-order/expected/build/manifest.json b/examples/higher-order/expected/build/manifest.json index 2cabe0814..6670cf42e 100644 --- a/examples/higher-order/expected/build/manifest.json +++ b/examples/higher-order/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"9782462874c8c1f265723a0caa09bad82e1eb4f62551148cbb759d3db1da1355","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"cad25c680b70cc19738e955d42f5338084e673ec5bb07afd260782dfba6d81fb"},{"byte_length":645,"kind":"project-config","path":"lexlean.toml","sha256":"63cb702cbed6f4e72305e820ab8e7310f3323d3244a100faf4c849ec4330110a"},{"byte_length":2489,"kind":"source","path":"src/Combinators.lex.tex","sha256":"2897acd583a9c31765e9da32301cde5132a25902e7549c23a1ce629eb94a4bf9"},{"byte_length":3168,"kind":"source","path":"src/Main.lex.tex","sha256":"639694334033c139f99b6a002940b094e4aac2fd1d50a80adcba1accccb4adb5"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"HigherOrder.Combinators","module":"Combinators","source_path":"src/Combinators.lex.tex"},{"lean_module":"HigherOrder.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":8967,"kind":"coverage","path":"coverage/HigherOrder/Combinators.coverage.json","sha256":"779593e39cdb5d165393afe9b60fcf4a3f1c035a4fd3df6f8f1738e081bc58e5"},{"byte_length":10374,"kind":"coverage","path":"coverage/HigherOrder/Main.coverage.json","sha256":"a49a19840ccc46c8be7b55b6db5e0b2bce9b9bbacd59ed831070ce6e51356830"},{"byte_length":1939,"kind":"lean","path":"modules/HigherOrder/Combinators.lean","sha256":"ba1d10dae60ef45d890c567b29320c1138baa0524aba40b5517d3e9dea3cb0b9"},{"byte_length":2689,"kind":"lean","path":"modules/HigherOrder/Main.lean","sha256":"5ca36cd0507376d552dab17320fff5ce6ed2bf31236a8eb27c1c8b3fd52224e6"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/Combinators.closure.json","sha256":"fae48e1888c045329cd97b90396673745ec6a61b5755fc5eba81998ce219bda9"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":3613,"kind":"map","path":"maps/HigherOrder/Combinators.map.json","sha256":"27343ecef7f98fdb14eca7a655677c7ac5757dbff6153587f110f7fd0648ff65"},{"byte_length":4862,"kind":"map","path":"maps/HigherOrder/Main.map.json","sha256":"201f32a5ec6914fa29c4226c7027812213b39cf76ada2cd20ba5ed5310769f73"},{"byte_length":3628,"kind":"tex","path":"modules/HigherOrder/Combinators.tex","sha256":"a1d0978dcb8841db9ee6d8ee416345122c237a6e3cc6d65689a75638a358ed17"},{"byte_length":4694,"kind":"tex","path":"modules/HigherOrder/Main.tex","sha256":"d81f718da50aac062cda1e68639966bbdcf9b897353ac8c3c23f6dfd8c4428b4"}],"project":"higher-order","selection":["Combinators","Main"],"semantic_id":"e5a01d2449b3b246c026e507417cc495d46a0e67241da855cb6160482b98a9dd","source_id":"900caaea784dcd8326315a0494198c04de19a59eca8bb810dfdc910878d1e1a9","spec":"lexlean/build-manifest/1"} +{"build_id":"1a737063464bd298b4952585542bbe08340b0826d4b308d234eb56e0a6a9d99e","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"39ac49fb3792f02d003ac88b9ee96bdc9f2c943941ec36ebe012ad30e5974a08"},{"byte_length":645,"kind":"project-config","path":"lexlean.toml","sha256":"63cb702cbed6f4e72305e820ab8e7310f3323d3244a100faf4c849ec4330110a"},{"byte_length":2489,"kind":"source","path":"src/Combinators.lex.tex","sha256":"2897acd583a9c31765e9da32301cde5132a25902e7549c23a1ce629eb94a4bf9"},{"byte_length":3168,"kind":"source","path":"src/Main.lex.tex","sha256":"639694334033c139f99b6a002940b094e4aac2fd1d50a80adcba1accccb4adb5"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"HigherOrder.Combinators","module":"Combinators","source_path":"src/Combinators.lex.tex"},{"lean_module":"HigherOrder.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":8967,"kind":"coverage","path":"coverage/HigherOrder/Combinators.coverage.json","sha256":"779593e39cdb5d165393afe9b60fcf4a3f1c035a4fd3df6f8f1738e081bc58e5"},{"byte_length":10374,"kind":"coverage","path":"coverage/HigherOrder/Main.coverage.json","sha256":"a49a19840ccc46c8be7b55b6db5e0b2bce9b9bbacd59ed831070ce6e51356830"},{"byte_length":1939,"kind":"lean","path":"modules/HigherOrder/Combinators.lean","sha256":"ba1d10dae60ef45d890c567b29320c1138baa0524aba40b5517d3e9dea3cb0b9"},{"byte_length":2689,"kind":"lean","path":"modules/HigherOrder/Main.lean","sha256":"5ca36cd0507376d552dab17320fff5ce6ed2bf31236a8eb27c1c8b3fd52224e6"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/Combinators.closure.json","sha256":"fae48e1888c045329cd97b90396673745ec6a61b5755fc5eba81998ce219bda9"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":3613,"kind":"map","path":"maps/HigherOrder/Combinators.map.json","sha256":"b727ea50a1f5ea6fa39b1e4c38cf6075404b0b51fc6c6093ebef70567d9ceeea"},{"byte_length":4862,"kind":"map","path":"maps/HigherOrder/Main.map.json","sha256":"1b2f7ecb7355b3651196f04b146f803f6eee32e6e9cc248a37d23f4576e0f62d"},{"byte_length":3628,"kind":"tex","path":"modules/HigherOrder/Combinators.tex","sha256":"a1d0978dcb8841db9ee6d8ee416345122c237a6e3cc6d65689a75638a358ed17"},{"byte_length":4694,"kind":"tex","path":"modules/HigherOrder/Main.tex","sha256":"d81f718da50aac062cda1e68639966bbdcf9b897353ac8c3c23f6dfd8c4428b4"}],"project":"higher-order","selection":["Combinators","Main"],"semantic_id":"b5934bc97e423cda9eec0f05d9678db72dbbde9e2fc250815ae781fbcef24ade","source_id":"ffdfb7956d15dc50a911119859eb3b794041edfb07cb3a688310f55ad46fa91e","spec":"lexlean/build-manifest/1"} diff --git a/examples/higher-order/expected/build/maps/HigherOrder/Combinators.map.json b/examples/higher-order/expected/build/maps/HigherOrder/Combinators.map.json index 6a07adbe6..f962f6130 100644 --- a/examples/higher-order/expected/build/maps/HigherOrder/Combinators.map.json +++ b/examples/higher-order/expected/build/maps/HigherOrder/Combinators.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/HigherOrder/Combinators.lean"},{"id":1,"kind":"tex","path":"modules/HigherOrder/Combinators.tex"}],"mappings":[{"artifact":0,"gen_end":206,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":0,"gen_end":504,"gen_start":206,"node":1,"role":"declaration","source":0,"src_end":494,"src_start":120},{"artifact":0,"gen_end":818,"gen_start":504,"node":2,"role":"declaration","source":0,"src_end":872,"src_start":496},{"artifact":0,"gen_end":1035,"gen_start":818,"node":3,"role":"declaration","source":0,"src_end":1140,"src_start":874},{"artifact":0,"gen_end":1102,"gen_start":1035,"node":4,"role":"declaration","source":0,"src_end":1258,"src_start":1142},{"artifact":0,"gen_end":1209,"gen_start":1102,"node":5,"role":"declaration","source":0,"src_end":1463,"src_start":1260},{"artifact":0,"gen_end":1338,"gen_start":1209,"node":6,"role":"declaration","source":0,"src_end":1684,"src_start":1465},{"artifact":0,"gen_end":1673,"gen_start":1338,"node":7,"role":"declaration","source":0,"src_end":2106,"src_start":1686},{"artifact":0,"gen_end":1910,"gen_start":1673,"node":8,"role":"declaration","source":0,"src_end":2453,"src_start":2108},{"artifact":0,"gen_end":1939,"gen_start":1910,"node":0,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":1,"gen_end":695,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":494,"src_start":120},{"artifact":1,"gen_end":1261,"gen_start":695,"node":11,"role":"declaration","source":0,"src_end":872,"src_start":496},{"artifact":1,"gen_end":1761,"gen_start":1261,"node":12,"role":"declaration","source":0,"src_end":1140,"src_start":874},{"artifact":1,"gen_end":2075,"gen_start":1761,"node":13,"role":"declaration","source":0,"src_end":1258,"src_start":1142},{"artifact":1,"gen_end":2330,"gen_start":2075,"node":14,"role":"declaration","source":0,"src_end":1463,"src_start":1260},{"artifact":1,"gen_end":2606,"gen_start":2330,"node":15,"role":"declaration","source":0,"src_end":1684,"src_start":1465},{"artifact":1,"gen_end":3111,"gen_start":2606,"node":16,"role":"declaration","source":0,"src_end":2106,"src_start":1686},{"artifact":1,"gen_end":3613,"gen_start":3111,"node":17,"role":"declaration","source":0,"src_end":2453,"src_start":2108},{"artifact":1,"gen_end":3628,"gen_start":3613,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":0}],"module":"Combinators","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"e5a01d2449b3b246c026e507417cc495d46a0e67241da855cb6160482b98a9dd","source_id":"900caaea784dcd8326315a0494198c04de19a59eca8bb810dfdc910878d1e1a9","sources":[{"id":0,"kind":"file","path":"src/Combinators.lex.tex","sha256":"2897acd583a9c31765e9da32301cde5132a25902e7549c23a1ce629eb94a4bf9"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/HigherOrder/Combinators.lean"},{"id":1,"kind":"tex","path":"modules/HigherOrder/Combinators.tex"}],"mappings":[{"artifact":0,"gen_end":206,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":0,"gen_end":504,"gen_start":206,"node":1,"role":"declaration","source":0,"src_end":494,"src_start":120},{"artifact":0,"gen_end":818,"gen_start":504,"node":2,"role":"declaration","source":0,"src_end":872,"src_start":496},{"artifact":0,"gen_end":1035,"gen_start":818,"node":3,"role":"declaration","source":0,"src_end":1140,"src_start":874},{"artifact":0,"gen_end":1102,"gen_start":1035,"node":4,"role":"declaration","source":0,"src_end":1258,"src_start":1142},{"artifact":0,"gen_end":1209,"gen_start":1102,"node":5,"role":"declaration","source":0,"src_end":1463,"src_start":1260},{"artifact":0,"gen_end":1338,"gen_start":1209,"node":6,"role":"declaration","source":0,"src_end":1684,"src_start":1465},{"artifact":0,"gen_end":1673,"gen_start":1338,"node":7,"role":"declaration","source":0,"src_end":2106,"src_start":1686},{"artifact":0,"gen_end":1910,"gen_start":1673,"node":8,"role":"declaration","source":0,"src_end":2453,"src_start":2108},{"artifact":0,"gen_end":1939,"gen_start":1910,"node":0,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":0},{"artifact":1,"gen_end":695,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":494,"src_start":120},{"artifact":1,"gen_end":1261,"gen_start":695,"node":11,"role":"declaration","source":0,"src_end":872,"src_start":496},{"artifact":1,"gen_end":1761,"gen_start":1261,"node":12,"role":"declaration","source":0,"src_end":1140,"src_start":874},{"artifact":1,"gen_end":2075,"gen_start":1761,"node":13,"role":"declaration","source":0,"src_end":1258,"src_start":1142},{"artifact":1,"gen_end":2330,"gen_start":2075,"node":14,"role":"declaration","source":0,"src_end":1463,"src_start":1260},{"artifact":1,"gen_end":2606,"gen_start":2330,"node":15,"role":"declaration","source":0,"src_end":1684,"src_start":1465},{"artifact":1,"gen_end":3111,"gen_start":2606,"node":16,"role":"declaration","source":0,"src_end":2106,"src_start":1686},{"artifact":1,"gen_end":3613,"gen_start":3111,"node":17,"role":"declaration","source":0,"src_end":2453,"src_start":2108},{"artifact":1,"gen_end":3628,"gen_start":3613,"node":9,"role":"declaration","source":0,"src_end":2489,"src_start":0}],"module":"Combinators","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"b5934bc97e423cda9eec0f05d9678db72dbbde9e2fc250815ae781fbcef24ade","source_id":"ffdfb7956d15dc50a911119859eb3b794041edfb07cb3a688310f55ad46fa91e","sources":[{"id":0,"kind":"file","path":"src/Combinators.lex.tex","sha256":"2897acd583a9c31765e9da32301cde5132a25902e7549c23a1ce629eb94a4bf9"}],"spec":"lexlean/source-map/1"} diff --git a/examples/higher-order/expected/build/maps/HigherOrder/Main.map.json b/examples/higher-order/expected/build/maps/HigherOrder/Main.map.json index 7b1229c50..f590d4363 100644 --- a/examples/higher-order/expected/build/maps/HigherOrder/Main.map.json +++ b/examples/higher-order/expected/build/maps/HigherOrder/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/HigherOrder/Main.lean"},{"id":1,"kind":"tex","path":"modules/HigherOrder/Main.tex"}],"mappings":[{"artifact":0,"gen_end":237,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":0,"gen_end":414,"gen_start":237,"node":1,"role":"declaration","source":0,"src_end":360,"src_start":140},{"artifact":0,"gen_end":582,"gen_start":414,"node":2,"role":"declaration","source":0,"src_end":563,"src_start":362},{"artifact":0,"gen_end":741,"gen_start":582,"node":3,"role":"declaration","source":0,"src_end":752,"src_start":565},{"artifact":0,"gen_end":928,"gen_start":741,"node":4,"role":"declaration","source":0,"src_end":949,"src_start":754},{"artifact":0,"gen_end":1192,"gen_start":928,"node":5,"role":"declaration","source":0,"src_end":1228,"src_start":951},{"artifact":0,"gen_end":1329,"gen_start":1192,"node":6,"role":"declaration","source":0,"src_end":1405,"src_start":1230},{"artifact":0,"gen_end":1430,"gen_start":1329,"node":7,"role":"declaration","source":0,"src_end":1552,"src_start":1407},{"artifact":0,"gen_end":1547,"gen_start":1430,"node":8,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":0,"gen_end":1613,"gen_start":1547,"node":9,"role":"declaration","source":0,"src_end":1825,"src_start":1709},{"artifact":0,"gen_end":2063,"gen_start":1613,"node":10,"role":"declaration","source":0,"src_end":2247,"src_start":1827},{"artifact":0,"gen_end":2416,"gen_start":2063,"node":11,"role":"declaration","source":0,"src_end":2795,"src_start":2249},{"artifact":0,"gen_end":2667,"gen_start":2416,"node":12,"role":"declaration","source":0,"src_end":3132,"src_start":2797},{"artifact":0,"gen_end":2689,"gen_start":2667,"node":0,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":1,"gen_end":635,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":360,"src_start":140},{"artifact":1,"gen_end":1126,"gen_start":635,"node":15,"role":"declaration","source":0,"src_end":563,"src_start":362},{"artifact":1,"gen_end":1532,"gen_start":1126,"node":16,"role":"declaration","source":0,"src_end":752,"src_start":565},{"artifact":1,"gen_end":1936,"gen_start":1532,"node":17,"role":"declaration","source":0,"src_end":949,"src_start":754},{"artifact":1,"gen_end":2567,"gen_start":1936,"node":18,"role":"declaration","source":0,"src_end":1228,"src_start":951},{"artifact":1,"gen_end":2814,"gen_start":2567,"node":19,"role":"declaration","source":0,"src_end":1405,"src_start":1230},{"artifact":1,"gen_end":3025,"gen_start":2814,"node":20,"role":"declaration","source":0,"src_end":1552,"src_start":1407},{"artifact":1,"gen_end":3252,"gen_start":3025,"node":21,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":1,"gen_end":3427,"gen_start":3252,"node":22,"role":"declaration","source":0,"src_end":1825,"src_start":1709},{"artifact":1,"gen_end":3987,"gen_start":3427,"node":23,"role":"declaration","source":0,"src_end":2247,"src_start":1827},{"artifact":1,"gen_end":4361,"gen_start":3987,"node":24,"role":"declaration","source":0,"src_end":2795,"src_start":2249},{"artifact":1,"gen_end":4679,"gen_start":4361,"node":25,"role":"declaration","source":0,"src_end":3132,"src_start":2797},{"artifact":1,"gen_end":4694,"gen_start":4679,"node":13,"role":"declaration","source":0,"src_end":3168,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"e5a01d2449b3b246c026e507417cc495d46a0e67241da855cb6160482b98a9dd","source_id":"900caaea784dcd8326315a0494198c04de19a59eca8bb810dfdc910878d1e1a9","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"639694334033c139f99b6a002940b094e4aac2fd1d50a80adcba1accccb4adb5"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/HigherOrder/Main.lean"},{"id":1,"kind":"tex","path":"modules/HigherOrder/Main.tex"}],"mappings":[{"artifact":0,"gen_end":237,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":0,"gen_end":414,"gen_start":237,"node":1,"role":"declaration","source":0,"src_end":360,"src_start":140},{"artifact":0,"gen_end":582,"gen_start":414,"node":2,"role":"declaration","source":0,"src_end":563,"src_start":362},{"artifact":0,"gen_end":741,"gen_start":582,"node":3,"role":"declaration","source":0,"src_end":752,"src_start":565},{"artifact":0,"gen_end":928,"gen_start":741,"node":4,"role":"declaration","source":0,"src_end":949,"src_start":754},{"artifact":0,"gen_end":1192,"gen_start":928,"node":5,"role":"declaration","source":0,"src_end":1228,"src_start":951},{"artifact":0,"gen_end":1329,"gen_start":1192,"node":6,"role":"declaration","source":0,"src_end":1405,"src_start":1230},{"artifact":0,"gen_end":1430,"gen_start":1329,"node":7,"role":"declaration","source":0,"src_end":1552,"src_start":1407},{"artifact":0,"gen_end":1547,"gen_start":1430,"node":8,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":0,"gen_end":1613,"gen_start":1547,"node":9,"role":"declaration","source":0,"src_end":1825,"src_start":1709},{"artifact":0,"gen_end":2063,"gen_start":1613,"node":10,"role":"declaration","source":0,"src_end":2247,"src_start":1827},{"artifact":0,"gen_end":2416,"gen_start":2063,"node":11,"role":"declaration","source":0,"src_end":2795,"src_start":2249},{"artifact":0,"gen_end":2667,"gen_start":2416,"node":12,"role":"declaration","source":0,"src_end":3132,"src_start":2797},{"artifact":0,"gen_end":2689,"gen_start":2667,"node":0,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3168,"src_start":0},{"artifact":1,"gen_end":635,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":360,"src_start":140},{"artifact":1,"gen_end":1126,"gen_start":635,"node":15,"role":"declaration","source":0,"src_end":563,"src_start":362},{"artifact":1,"gen_end":1532,"gen_start":1126,"node":16,"role":"declaration","source":0,"src_end":752,"src_start":565},{"artifact":1,"gen_end":1936,"gen_start":1532,"node":17,"role":"declaration","source":0,"src_end":949,"src_start":754},{"artifact":1,"gen_end":2567,"gen_start":1936,"node":18,"role":"declaration","source":0,"src_end":1228,"src_start":951},{"artifact":1,"gen_end":2814,"gen_start":2567,"node":19,"role":"declaration","source":0,"src_end":1405,"src_start":1230},{"artifact":1,"gen_end":3025,"gen_start":2814,"node":20,"role":"declaration","source":0,"src_end":1552,"src_start":1407},{"artifact":1,"gen_end":3252,"gen_start":3025,"node":21,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":1,"gen_end":3427,"gen_start":3252,"node":22,"role":"declaration","source":0,"src_end":1825,"src_start":1709},{"artifact":1,"gen_end":3987,"gen_start":3427,"node":23,"role":"declaration","source":0,"src_end":2247,"src_start":1827},{"artifact":1,"gen_end":4361,"gen_start":3987,"node":24,"role":"declaration","source":0,"src_end":2795,"src_start":2249},{"artifact":1,"gen_end":4679,"gen_start":4361,"node":25,"role":"declaration","source":0,"src_end":3132,"src_start":2797},{"artifact":1,"gen_end":4694,"gen_start":4679,"node":13,"role":"declaration","source":0,"src_end":3168,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"b5934bc97e423cda9eec0f05d9678db72dbbde9e2fc250815ae781fbcef24ade","source_id":"ffdfb7956d15dc50a911119859eb3b794041edfb07cb3a688310f55ad46fa91e","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"639694334033c139f99b6a002940b094e4aac2fd1d50a80adcba1accccb4adb5"}],"spec":"lexlean/source-map/1"} diff --git a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.lean b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.lean similarity index 100% rename from examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.lean rename to examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.lean diff --git a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.process.json b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.process.json similarity index 80% rename from examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.process.json rename to examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.process.json index 435d6b891..f0ca17951 100644 --- a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.process.json +++ b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Combinators","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'HigherOrder.Combinators.Arith' does not depend on any axioms\n'HigherOrder.Combinators.Visitor' does not depend on any axioms\n'HigherOrder.Combinators.compose' does not depend on any axioms\n'HigherOrder.Combinators.evaluate' does not depend on any axioms\n'HigherOrder.Combinators.foldList' does not depend on any axioms\n'HigherOrder.Combinators.increment' does not depend on any axioms\n'HigherOrder.Combinators.mapList' does not depend on any axioms\n'HigherOrder.Combinators.visit' does not depend on any axioms\n","stdout_sha256":"de1e33aa3f1e3e8770d289a02cc7469a8a96a5958bc23bca0cccd7b9b7805bfc","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Combinators","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'HigherOrder.Combinators.Arith' does not depend on any axioms\n'HigherOrder.Combinators.Visitor' does not depend on any axioms\n'HigherOrder.Combinators.compose' does not depend on any axioms\n'HigherOrder.Combinators.evaluate' does not depend on any axioms\n'HigherOrder.Combinators.foldList' does not depend on any axioms\n'HigherOrder.Combinators.increment' does not depend on any axioms\n'HigherOrder.Combinators.mapList' does not depend on any axioms\n'HigherOrder.Combinators.visit' does not depend on any axioms\n","stdout_sha256":"de1e33aa3f1e3e8770d289a02cc7469a8a96a5958bc23bca0cccd7b9b7805bfc","tool":"lean"} diff --git a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.lean b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.lean similarity index 100% rename from examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.lean rename to examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.lean diff --git a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.process.json b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.process.json similarity index 78% rename from examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.process.json rename to examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.process.json index f594d7715..7be66bd43 100644 --- a/examples/higher-order/expected/verify/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.process.json +++ b/examples/higher-order/expected/verify/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae5a01d2449b3b246c026e507417cc495.HigherOrder.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'HigherOrder.Main.addAll' does not depend on any axioms\n'HigherOrder.Main.addThenDouble' does not depend on any axioms\n'HigherOrder.Main.add_all' does not depend on any axioms\n'HigherOrder.Main.bumpAll' does not depend on any axioms\n'HigherOrder.Main.bump_all' does not depend on any axioms\n'HigherOrder.Main.composed' does not depend on any axioms\n'HigherOrder.Main.evaluator' does not depend on any axioms\n'HigherOrder.Main.map_identity' depends on axioms: [propext]\n'HigherOrder.Main.map_identity_numbers' depends on axioms: [propext]\n'HigherOrder.Main.total' does not depend on any axioms\n'HigherOrder.Main.total_sum' does not depend on any axioms\n'HigherOrder.Main.visitor_agrees' does not depend on any axioms\n","stdout_sha256":"9e0e7e9c7139fa04a4a7345994d644c70eff086f8c7a7a5afa2bfb7e457c1764","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ab5934bc97e423cda9eec0f05d9678db7.HigherOrder.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'HigherOrder.Main.addAll' does not depend on any axioms\n'HigherOrder.Main.addThenDouble' does not depend on any axioms\n'HigherOrder.Main.add_all' does not depend on any axioms\n'HigherOrder.Main.bumpAll' does not depend on any axioms\n'HigherOrder.Main.bump_all' does not depend on any axioms\n'HigherOrder.Main.composed' does not depend on any axioms\n'HigherOrder.Main.evaluator' does not depend on any axioms\n'HigherOrder.Main.map_identity' depends on axioms: [propext]\n'HigherOrder.Main.map_identity_numbers' depends on axioms: [propext]\n'HigherOrder.Main.total' does not depend on any axioms\n'HigherOrder.Main.total_sum' does not depend on any axioms\n'HigherOrder.Main.visitor_agrees' does not depend on any axioms\n","stdout_sha256":"9e0e7e9c7139fa04a4a7345994d644c70eff086f8c7a7a5afa2bfb7e457c1764","tool":"lean"} diff --git a/examples/higher-order/expected/verify/probe/LexLeanProbe.Pe5a01d2449b3b246c026e507417cc495.lean b/examples/higher-order/expected/verify/probe/LexLeanProbe.Pb5934bc97e423cda9eec0f05d9678db7.lean similarity index 100% rename from examples/higher-order/expected/verify/probe/LexLeanProbe.Pe5a01d2449b3b246c026e507417cc495.lean rename to examples/higher-order/expected/verify/probe/LexLeanProbe.Pb5934bc97e423cda9eec0f05d9678db7.lean diff --git a/examples/higher-order/expected/verify/probe/process.json b/examples/higher-order/expected/verify/probe/process.json index 0db3ec619..5f3bcc234 100644 --- a/examples/higher-order/expected/verify/probe/process.json +++ b/examples/higher-order/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pe5a01d2449b3b246c026e507417cc495.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pe5a01d2449b3b246c026e507417cc495","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pb5934bc97e423cda9eec0f05d9678db7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pb5934bc97e423cda9eec0f05d9678db7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/higher-order/lexlean.lock b/examples/higher-order/lexlean.lock index 95766de49..f9fdcd36b 100644 --- a/examples/higher-order/lexlean.lock +++ b/examples/higher-order/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "63cb702cbed6f4e72305e820ab8e7310f3323d3244a100faf4c849ec4330110a" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/language-1.2/expected/build/manifest.json b/examples/language-1.2/expected/build/manifest.json index 3ff5288ae..2d16f840f 100644 --- a/examples/language-1.2/expected/build/manifest.json +++ b/examples/language-1.2/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"1475b4c63f4f019af6248d4b04fc7585a368f6b2bee98b853079a676bf9427d0","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"a5a10f7bdd52ae1c601cfedd1676424bc8d42e523c3827979507e8c433221b95"},{"byte_length":651,"kind":"project-config","path":"lexlean.toml","sha256":"6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d"},{"byte_length":551,"kind":"source","path":"src/Main.lex.tex","sha256":"953f3abc01c25e1b7f7660030023464667bcfd01a05e0b92a30b52ded0a4e0f9"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LanguageTwelve.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":7313,"kind":"coverage","path":"coverage/LanguageTwelve/Main.coverage.json","sha256":"dbda5c8a9d0d3d7b1083172702012ff50ea7b5a4887b712ea58d51f3f8449e48"},{"byte_length":508,"kind":"lean","path":"modules/LanguageTwelve/Main.lean","sha256":"a0c1babda5d001501ce7db4d5b691711a049f6d4735bc5bf74bdbeadda4320e0"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":1971,"kind":"map","path":"maps/LanguageTwelve/Main.map.json","sha256":"612aeae0c9e9057c83a844879e37520b70c89af185ec96a726c4e7602f356638"},{"byte_length":834,"kind":"tex","path":"modules/LanguageTwelve/Main.tex","sha256":"c1b7005570e64d41f460dbb1d974d941e5c5e36d43e9c2bfc64fbd9dca26e11b"}],"project":"language-twelve","selection":["Main"],"semantic_id":"91252ea0ee170a673bd0462010771fa8f2a1003d1c1dde186b221fed42f2c92e","source_id":"597e4c79d1382afb0adef6c533bb53d30663375b89a4a5fb008a35d1ce41c32e","spec":"lexlean/build-manifest/1"} +{"build_id":"627ce1060d62b964606d1af1321ddda66323209fb971574de727d29c413aaa2f","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"5c6d7fc042fdf73b33150f5033c4538fb300221698e7f6267e4d524d464dca8d"},{"byte_length":651,"kind":"project-config","path":"lexlean.toml","sha256":"6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d"},{"byte_length":551,"kind":"source","path":"src/Main.lex.tex","sha256":"953f3abc01c25e1b7f7660030023464667bcfd01a05e0b92a30b52ded0a4e0f9"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LanguageTwelve.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":7313,"kind":"coverage","path":"coverage/LanguageTwelve/Main.coverage.json","sha256":"dbda5c8a9d0d3d7b1083172702012ff50ea7b5a4887b712ea58d51f3f8449e48"},{"byte_length":508,"kind":"lean","path":"modules/LanguageTwelve/Main.lean","sha256":"a0c1babda5d001501ce7db4d5b691711a049f6d4735bc5bf74bdbeadda4320e0"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":1971,"kind":"map","path":"maps/LanguageTwelve/Main.map.json","sha256":"d41aac35a3320051fee760c3f177769d1310efa16eba63627114403d435e80cf"},{"byte_length":834,"kind":"tex","path":"modules/LanguageTwelve/Main.tex","sha256":"c1b7005570e64d41f460dbb1d974d941e5c5e36d43e9c2bfc64fbd9dca26e11b"}],"project":"language-twelve","selection":["Main"],"semantic_id":"8f90c02b42edd596631d3fdfeeada166814d54f55ea1874ed55a5b6f071fd409","source_id":"44d0ce4799789f60a676e7b3756945674ba9c6743d516cb1b7a33f8fdf9dd9a9","spec":"lexlean/build-manifest/1"} diff --git a/examples/language-1.2/expected/build/maps/LanguageTwelve/Main.map.json b/examples/language-1.2/expected/build/maps/LanguageTwelve/Main.map.json index cdfff8685..6ba616f05 100644 --- a/examples/language-1.2/expected/build/maps/LanguageTwelve/Main.map.json +++ b/examples/language-1.2/expected/build/maps/LanguageTwelve/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LanguageTwelve/Main.lean"},{"id":1,"kind":"tex","path":"modules/LanguageTwelve/Main.tex"}],"mappings":[{"artifact":0,"gen_end":202,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":0,"gen_end":306,"gen_start":202,"node":1,"role":"declaration","source":0,"src_end":246,"src_start":113},{"artifact":0,"gen_end":385,"gen_start":306,"node":2,"role":"declaration","source":0,"src_end":371,"src_start":248},{"artifact":0,"gen_end":483,"gen_start":385,"node":3,"role":"declaration","source":0,"src_end":515,"src_start":373},{"artifact":0,"gen_end":508,"gen_start":483,"node":0,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":4,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":1,"gen_end":420,"gen_start":134,"node":5,"role":"declaration","source":0,"src_end":246,"src_start":113},{"artifact":1,"gen_end":610,"gen_start":420,"node":6,"role":"declaration","source":0,"src_end":371,"src_start":248},{"artifact":1,"gen_end":819,"gen_start":610,"node":7,"role":"declaration","source":0,"src_end":515,"src_start":373},{"artifact":1,"gen_end":834,"gen_start":819,"node":4,"role":"declaration","source":0,"src_end":551,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-latex-module"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"}],"semantic_id":"91252ea0ee170a673bd0462010771fa8f2a1003d1c1dde186b221fed42f2c92e","source_id":"597e4c79d1382afb0adef6c533bb53d30663375b89a4a5fb008a35d1ce41c32e","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"953f3abc01c25e1b7f7660030023464667bcfd01a05e0b92a30b52ded0a4e0f9"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LanguageTwelve/Main.lean"},{"id":1,"kind":"tex","path":"modules/LanguageTwelve/Main.tex"}],"mappings":[{"artifact":0,"gen_end":202,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":0,"gen_end":306,"gen_start":202,"node":1,"role":"declaration","source":0,"src_end":246,"src_start":113},{"artifact":0,"gen_end":385,"gen_start":306,"node":2,"role":"declaration","source":0,"src_end":371,"src_start":248},{"artifact":0,"gen_end":483,"gen_start":385,"node":3,"role":"declaration","source":0,"src_end":515,"src_start":373},{"artifact":0,"gen_end":508,"gen_start":483,"node":0,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":4,"role":"declaration","source":0,"src_end":551,"src_start":0},{"artifact":1,"gen_end":420,"gen_start":134,"node":5,"role":"declaration","source":0,"src_end":246,"src_start":113},{"artifact":1,"gen_end":610,"gen_start":420,"node":6,"role":"declaration","source":0,"src_end":371,"src_start":248},{"artifact":1,"gen_end":819,"gen_start":610,"node":7,"role":"declaration","source":0,"src_end":515,"src_start":373},{"artifact":1,"gen_end":834,"gen_start":819,"node":4,"role":"declaration","source":0,"src_end":551,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-latex-module"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"}],"semantic_id":"8f90c02b42edd596631d3fdfeeada166814d54f55ea1874ed55a5b6f071fd409","source_id":"44d0ce4799789f60a676e7b3756945674ba9c6743d516cb1b7a33f8fdf9dd9a9","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"953f3abc01c25e1b7f7660030023464667bcfd01a05e0b92a30b52ded0a4e0f9"}],"spec":"lexlean/source-map/1"} diff --git a/examples/language-1.2/expected/verify/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.lean b/examples/language-1.2/expected/verify/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.lean similarity index 100% rename from examples/language-1.2/expected/verify/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.lean rename to examples/language-1.2/expected/verify/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.lean diff --git a/examples/language-1.2/expected/verify/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.process.json b/examples/language-1.2/expected/verify/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.process.json similarity index 61% rename from examples/language-1.2/expected/verify/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.process.json rename to examples/language-1.2/expected/verify/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.process.json index 9f1c01828..53b8f96fe 100644 --- a/examples/language-1.2/expected/verify/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.process.json +++ b/examples/language-1.2/expected/verify/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91252ea0ee170a673bd0462010771fa8.LanguageTwelve.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LanguageTwelve.Main.doubledSuccessor' does not depend on any axioms\n'LanguageTwelve.Main.doubled_successor_two' does not depend on any axioms\n'LanguageTwelve.Main.let_statement_unfolds' does not depend on any axioms\n","stdout_sha256":"96052f032fc09970e5f3f333cca6d8656a749c07d2832f02c21c3cbff2caafa0","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A8f90c02b42edd596631d3fdfeeada166.LanguageTwelve.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LanguageTwelve.Main.doubledSuccessor' does not depend on any axioms\n'LanguageTwelve.Main.doubled_successor_two' does not depend on any axioms\n'LanguageTwelve.Main.let_statement_unfolds' does not depend on any axioms\n","stdout_sha256":"96052f032fc09970e5f3f333cca6d8656a749c07d2832f02c21c3cbff2caafa0","tool":"lean"} diff --git a/examples/language-1.2/expected/verify/probe/LexLeanProbe.P91252ea0ee170a673bd0462010771fa8.lean b/examples/language-1.2/expected/verify/probe/LexLeanProbe.P8f90c02b42edd596631d3fdfeeada166.lean similarity index 100% rename from examples/language-1.2/expected/verify/probe/LexLeanProbe.P91252ea0ee170a673bd0462010771fa8.lean rename to examples/language-1.2/expected/verify/probe/LexLeanProbe.P8f90c02b42edd596631d3fdfeeada166.lean diff --git a/examples/language-1.2/expected/verify/probe/process.json b/examples/language-1.2/expected/verify/probe/process.json index 6a8a4e7e0..f78d6cfc7 100644 --- a/examples/language-1.2/expected/verify/probe/process.json +++ b/examples/language-1.2/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P91252ea0ee170a673bd0462010771fa8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P91252ea0ee170a673bd0462010771fa8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P8f90c02b42edd596631d3fdfeeada166.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P8f90c02b42edd596631d3fdfeeada166","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/language-1.2/lexlean.lock b/examples/language-1.2/lexlean.lock index f326b4b18..a84849b34 100644 --- a/examples/language-1.2/lexlean.lock +++ b/examples/language-1.2/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/models/expected/build/manifest.json b/examples/models/expected/build/manifest.json index ec884b6f6..b57b42e81 100644 --- a/examples/models/expected/build/manifest.json +++ b/examples/models/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"f429f1ac2de18973bbf72302bd4c103e89027e7876b407963fd8133714915362","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":4811,"kind":"lexicon","path":"glossary/models.titles","sha256":"0b8dcd3efdfb82e5f572dcf1e598744aaba14c52e1c66f5300c5ed83d4b5e1be"},{"byte_length":1939,"kind":"lock","path":"lexlean.lock","sha256":"7b2cb774e7ab429db2074870595fa7bf693c0db936ce66ffda40d405928ae19e"},{"byte_length":5,"kind":"model-artifact","path":"artifacts/banner.bin","sha256":"3369421cb6a657bcbdbec197a0c3b2a8e208dd7746853513f9d77331d0fa1397"},{"byte_length":50,"kind":"model-artifact","path":"artifacts/digit-names.txt","sha256":"476e03af7ff499e63fe93fffa0567a69128761f538ec7dd1f3e2c197a0c90981"},{"byte_length":48,"kind":"model-artifact","path":"artifacts/hidden-bias.bin","sha256":"102bf7ceb176bc23dd4abb56dada713135d79093a79c20c7c79471f751f9a778"},{"byte_length":84,"kind":"model-artifact","path":"artifacts/hidden-weights.bin","sha256":"670b5066543781ad41947e253f1e5dd45157070e78116a588dc2b6bcea2e7bd8"},{"byte_length":40,"kind":"model-artifact","path":"artifacts/output-bias.bin","sha256":"ba0505206b75f60de72e117e01155033a68c40972a7f6687a2b05ca0004c5ab4"},{"byte_length":120,"kind":"model-artifact","path":"artifacts/output-weights.bin","sha256":"6a536cff5b44d31e45ff9b128794e29c3fe9c09bad111f0dbe9df3fc29941de7"},{"byte_length":6,"kind":"model-artifact","path":"artifacts/triage-bias.bin","sha256":"34b5d0d734084832dea276360f994018f4e6eb7921334265e58217b360a2a79d"},{"byte_length":18,"kind":"model-artifact","path":"artifacts/triage-weights.bin","sha256":"7a1039fea753fdbab50d96e9b180fb5f987c6ba688d847da0e209608c5c0f58e"},{"byte_length":1786,"kind":"project-config","path":"lexlean.toml","sha256":"b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a"},{"byte_length":13246,"kind":"source","path":"src/Flows.lex.tex","sha256":"28ec74d66a4db50353250e50c656dd75d6e0555eaacc19fbd37c573f8e938c33"},{"byte_length":3921,"kind":"source","path":"src/Glyphs.lex.tex","sha256":"14f0f695eb5d2853be86d0599bc52cad41f92c971c4b8b69ac77ddc0635d3b70"},{"byte_length":13264,"kind":"source","path":"src/Ledger.lex.tex","sha256":"4eaf7867fbd19e7f03c139d4f5bfa753cc7022d2c1f2faf6b849abecff4e9815"},{"byte_length":13995,"kind":"source","path":"src/Main.lex.tex","sha256":"09fef2732bb2b95f41909df0570942389cddbf5bcefe01e667b6ec7400caad75"},{"byte_length":12945,"kind":"source","path":"src/Pipeline.lex.tex","sha256":"82cec7477a537982dab7be86130292d11e3cc2123c2e7188a32b8d8808ab22c1"},{"byte_length":3172,"kind":"source","path":"src/Policy.lex.tex","sha256":"32d2ea99e908b81d5210299ee8e6148cc87e4ae72d9bef235cadf5cf69947ecf"},{"byte_length":8290,"kind":"source","path":"src/Recognizer.lex.tex","sha256":"28bd37cb2876ff04da7a9efddf50a52d3019c64910aca2b806b4b6181e84b04b"},{"byte_length":3686,"kind":"source","path":"src/Session.lex.tex","sha256":"0077c43c5251814a8329dc387538b9d0aafb0780238f61ce60bb245e9a15bbb1"},{"byte_length":6766,"kind":"source","path":"src/Triage.lex.tex","sha256":"61ce4693fcb18df340d1f0f9a9a0d29a73912cc4075bd20dcbda09508373808b"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Models.Flows","module":"Flows","source_path":"src/Flows.lex.tex"},{"lean_module":"Models.Glyphs","module":"Glyphs","source_path":"src/Glyphs.lex.tex"},{"lean_module":"Models.Ledger","module":"Ledger","source_path":"src/Ledger.lex.tex"},{"lean_module":"Models.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Models.Pipeline","module":"Pipeline","source_path":"src/Pipeline.lex.tex"},{"lean_module":"Models.Policy","module":"Policy","source_path":"src/Policy.lex.tex"},{"lean_module":"Models.Recognizer","module":"Recognizer","source_path":"src/Recognizer.lex.tex"},{"lean_module":"Models.Session","module":"Session","source_path":"src/Session.lex.tex"},{"lean_module":"Models.Triage","module":"Triage","source_path":"src/Triage.lex.tex"}],"outputs":[{"byte_length":24217,"kind":"coverage","path":"coverage/Models/Flows.coverage.json","sha256":"e9b1f6037cee26e0cdc097c7bc65ed0345263b1ed4463ed7d210eafaad1adff4"},{"byte_length":9847,"kind":"coverage","path":"coverage/Models/Glyphs.coverage.json","sha256":"072aea809bb4e07810443bd6655b3dbedd5ffc81ee90b3b281013c7dc18f0001"},{"byte_length":25557,"kind":"coverage","path":"coverage/Models/Ledger.coverage.json","sha256":"8029c3cef9485dee7bf5585898f5416186731f9b0ec1df5b5186865278447b01"},{"byte_length":30015,"kind":"coverage","path":"coverage/Models/Main.coverage.json","sha256":"477bcd9b3e0f0d6061de1f0e125668d19ca0a963a869aebd621c4f8361f9d42d"},{"byte_length":24131,"kind":"coverage","path":"coverage/Models/Pipeline.coverage.json","sha256":"e082ea27d2b6e96f9168548252aa12f19153ef34d27b5031617fd7720cbabb88"},{"byte_length":12248,"kind":"coverage","path":"coverage/Models/Policy.coverage.json","sha256":"04dc9b952a28d723f62e3b56b063eddd9953f0aefd29d3897e66bc735ff78445"},{"byte_length":15495,"kind":"coverage","path":"coverage/Models/Recognizer.coverage.json","sha256":"69fdda5a237d1935f7ca26006e6560af6dcbebadb69d17f227a2429866e7cbb9"},{"byte_length":12487,"kind":"coverage","path":"coverage/Models/Session.coverage.json","sha256":"480eff88eec1169a6d701a53c9669598b579ce0699d75c695d043020180095ed"},{"byte_length":13513,"kind":"coverage","path":"coverage/Models/Triage.coverage.json","sha256":"5837a31c1b4d9651670e477b15abfb0c466a57d9b777987c99f059e2b3a02ac5"},{"byte_length":62836,"kind":"lean","path":"modules/Models/Flows.lean","sha256":"871a71c6eed0efaca275f805e9b26dd7eb07d1bbf0d6fccaf65fd0ffcbf61f3e"},{"byte_length":2855,"kind":"lean","path":"modules/Models/Glyphs.lean","sha256":"8aa86a6b8345f27ccbe31ec8e215ccbc41f5a94b80b06b46c9a953e230e2f14c"},{"byte_length":67242,"kind":"lean","path":"modules/Models/Ledger.lean","sha256":"6097dcedded56f40246156dbf0b299695566039e964ca0e1cc1e95641bd9cdac"},{"byte_length":17668,"kind":"lean","path":"modules/Models/Main.lean","sha256":"658e891f7761222d52582f26186d208769621fdabaa1a0309cba849c8f0d0509"},{"byte_length":15495,"kind":"lean","path":"modules/Models/Pipeline.lean","sha256":"0974e254daa6ea324063802ef965309e195c2cadb3ff154a7ecab65e011e2cb1"},{"byte_length":2673,"kind":"lean","path":"modules/Models/Policy.lean","sha256":"75af53ee823cb3b3a8a2fa5518ca4705eaf5cd16ff963e45a936a3bc888f2105"},{"byte_length":25032,"kind":"lean","path":"modules/Models/Recognizer.lean","sha256":"c3c1a25b313cdf4e12d29fad952adf3d0e4fc0c8d8f4c2d4ba6db942e53a3b09"},{"byte_length":15239,"kind":"lean","path":"modules/Models/Session.lean","sha256":"6b3037069b9b123c316c85e9a2126779078ed85ea658a8d04ae4693582185074"},{"byte_length":7179,"kind":"lean","path":"modules/Models/Triage.lean","sha256":"da0208edd92e97b9d9052875c679a7a6954bd41f37497e00ddcf40d47389147b"},{"byte_length":11477,"kind":"lexicon-closure","path":"lexicons/Flows.closure.json","sha256":"858b26caa8a4ba472b9fda1c075790e289bad1bc2c8fd9972ce01c780e1249d5"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Glyphs.closure.json","sha256":"de21ab7949a2df29237c6a4d7f321091f5acd24d46fa1807cdbc0b65f864b27a"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Ledger.closure.json","sha256":"f9388586b5a83a1936fb2a98fc17b01d7cd07e13687d01d5899a3688adb62427"},{"byte_length":11476,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"76718e3e6f6a37d3170b892b6beafe27c8a80a81ff6c957e571441ddcf81b1d6"},{"byte_length":11480,"kind":"lexicon-closure","path":"lexicons/Pipeline.closure.json","sha256":"83cdbac593b6281d194e892e8c635551073cd5113cf47b84e4aa8dc3165cb4ae"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Policy.closure.json","sha256":"cfea6fccd554628e92aa4e4ab9501276443605e9b7b7222894a9345acdeeaf5c"},{"byte_length":11482,"kind":"lexicon-closure","path":"lexicons/Recognizer.closure.json","sha256":"9297441e84743784deedc603cbc74d71441164d59f788c3b6c0e7bbb3ac6e2a8"},{"byte_length":11479,"kind":"lexicon-closure","path":"lexicons/Session.closure.json","sha256":"8300e307091b03c0b18bafb8be0a476514693fddaac26c9481b5bec9bc1908f8"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Triage.closure.json","sha256":"b2f32bd383076cd4db64bfbc67ef975f94d237edb76f59a156317639270e482f"},{"byte_length":19292,"kind":"map","path":"maps/Models/Flows.map.json","sha256":"1a530c893156915c9539e4d951fa396c7344564dfdddc18c016e89bcab43d37d"},{"byte_length":2945,"kind":"map","path":"maps/Models/Glyphs.map.json","sha256":"527239448d7296f56693b016e0cd931074491a98f5c0cbc72bfeedb9e9893cd2"},{"byte_length":21594,"kind":"map","path":"maps/Models/Ledger.map.json","sha256":"ef56fc44cdbb83244f2fac09e1a0793caa1ccfc4481c6929da0b2ea89df2c1cf"},{"byte_length":21960,"kind":"map","path":"maps/Models/Main.map.json","sha256":"7b3537a095ec810fbdfad6f67976468bd954bceffcfe8b105e8eb5b11608a625"},{"byte_length":15952,"kind":"map","path":"maps/Models/Pipeline.map.json","sha256":"257e99d80b95be47655470f79d9731f17c9194e3ac18c994bb8c98cf6faf547f"},{"byte_length":4862,"kind":"map","path":"maps/Models/Policy.map.json","sha256":"61b9407d57a8920dbbdbfcfef29a4b9a3c23a29ec48b37f42344189fbaa3ad65"},{"byte_length":8484,"kind":"map","path":"maps/Models/Recognizer.map.json","sha256":"73a4a001fe45cea3a8f5bc9f63f04b3cfbb0a768aaca20249ad010441148b56f"},{"byte_length":5833,"kind":"map","path":"maps/Models/Session.map.json","sha256":"52a7a4a9587144d80a8153b65baab7bfa46f73c5a8d711c0ce387f6f6bfb1569"},{"byte_length":7133,"kind":"map","path":"maps/Models/Triage.map.json","sha256":"9ed5be22d4de37d26090ab348781c4662e162b371a2250c496ceac15f421671d"},{"byte_length":79615,"kind":"production-eligibility","path":"production/Models/Main.eligibility.json","sha256":"e65c147e2755a7f0140521b73588e6e206590c70f8d3c313a6b13be2420dd3b8"},{"byte_length":37412,"kind":"tex","path":"modules/Models/Flows.tex","sha256":"a7ad124df989dba8e1e5d673c9cc40e6d4b9b5f2a66821d04dc0cbc5ce3bb174"},{"byte_length":4181,"kind":"tex","path":"modules/Models/Glyphs.tex","sha256":"6996f9482d5460c45ac62c9cd8bbe44b376ad98661730c898501535ca39ef537"},{"byte_length":32582,"kind":"tex","path":"modules/Models/Ledger.tex","sha256":"86863d003899b6037aab9ed859608ac66c19ca0f594b2e363577e9cd8c8bae65"},{"byte_length":22675,"kind":"tex","path":"modules/Models/Main.tex","sha256":"99c225ea6da22156c56975a427fb5529abe3b64087760d5962c94a929228b17b"},{"byte_length":22804,"kind":"tex","path":"modules/Models/Pipeline.tex","sha256":"8afd93d17cfb93d15d0a453f85434722a713b25c57ee79637885d6a43bfa1a57"},{"byte_length":5668,"kind":"tex","path":"modules/Models/Policy.tex","sha256":"9b896db44315af8db6859dcb061178eef227967f4835c897f47bd5df85b7649d"},{"byte_length":18868,"kind":"tex","path":"modules/Models/Recognizer.tex","sha256":"4fda5d8ad4890ae385da68c4be4c23b44a5e021869b92e6c599469bfde00e1ba"},{"byte_length":7934,"kind":"tex","path":"modules/Models/Session.tex","sha256":"bdee6203c11a7e19bbcb0cbc81c785c5c8168dc450c4f167215e2d2f4a19dd14"},{"byte_length":11815,"kind":"tex","path":"modules/Models/Triage.tex","sha256":"37fe90aac05faee917c08a1ff9faa63403cf7e42459bad80798152739099b827"}],"project":"models","selection":["Flows","Glyphs","Ledger","Main","Pipeline","Policy","Recognizer","Session","Triage"],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","spec":"lexlean/build-manifest/1"} +{"build_id":"618767111e40546cbf7aa237732be6717a8997c0c2632b8f5f14d2506e84dc1e","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":4811,"kind":"lexicon","path":"glossary/models.titles","sha256":"0b8dcd3efdfb82e5f572dcf1e598744aaba14c52e1c66f5300c5ed83d4b5e1be"},{"byte_length":1939,"kind":"lock","path":"lexlean.lock","sha256":"0aa8b0ac2226c2f5a7edb072636b7c97536b3448eecd16cd29cb9ea210c718a5"},{"byte_length":5,"kind":"model-artifact","path":"artifacts/banner.bin","sha256":"3369421cb6a657bcbdbec197a0c3b2a8e208dd7746853513f9d77331d0fa1397"},{"byte_length":50,"kind":"model-artifact","path":"artifacts/digit-names.txt","sha256":"476e03af7ff499e63fe93fffa0567a69128761f538ec7dd1f3e2c197a0c90981"},{"byte_length":48,"kind":"model-artifact","path":"artifacts/hidden-bias.bin","sha256":"102bf7ceb176bc23dd4abb56dada713135d79093a79c20c7c79471f751f9a778"},{"byte_length":84,"kind":"model-artifact","path":"artifacts/hidden-weights.bin","sha256":"670b5066543781ad41947e253f1e5dd45157070e78116a588dc2b6bcea2e7bd8"},{"byte_length":40,"kind":"model-artifact","path":"artifacts/output-bias.bin","sha256":"ba0505206b75f60de72e117e01155033a68c40972a7f6687a2b05ca0004c5ab4"},{"byte_length":120,"kind":"model-artifact","path":"artifacts/output-weights.bin","sha256":"6a536cff5b44d31e45ff9b128794e29c3fe9c09bad111f0dbe9df3fc29941de7"},{"byte_length":6,"kind":"model-artifact","path":"artifacts/triage-bias.bin","sha256":"34b5d0d734084832dea276360f994018f4e6eb7921334265e58217b360a2a79d"},{"byte_length":18,"kind":"model-artifact","path":"artifacts/triage-weights.bin","sha256":"7a1039fea753fdbab50d96e9b180fb5f987c6ba688d847da0e209608c5c0f58e"},{"byte_length":1786,"kind":"project-config","path":"lexlean.toml","sha256":"b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a"},{"byte_length":13246,"kind":"source","path":"src/Flows.lex.tex","sha256":"28ec74d66a4db50353250e50c656dd75d6e0555eaacc19fbd37c573f8e938c33"},{"byte_length":3921,"kind":"source","path":"src/Glyphs.lex.tex","sha256":"14f0f695eb5d2853be86d0599bc52cad41f92c971c4b8b69ac77ddc0635d3b70"},{"byte_length":13264,"kind":"source","path":"src/Ledger.lex.tex","sha256":"4eaf7867fbd19e7f03c139d4f5bfa753cc7022d2c1f2faf6b849abecff4e9815"},{"byte_length":13995,"kind":"source","path":"src/Main.lex.tex","sha256":"09fef2732bb2b95f41909df0570942389cddbf5bcefe01e667b6ec7400caad75"},{"byte_length":12945,"kind":"source","path":"src/Pipeline.lex.tex","sha256":"82cec7477a537982dab7be86130292d11e3cc2123c2e7188a32b8d8808ab22c1"},{"byte_length":3172,"kind":"source","path":"src/Policy.lex.tex","sha256":"32d2ea99e908b81d5210299ee8e6148cc87e4ae72d9bef235cadf5cf69947ecf"},{"byte_length":8290,"kind":"source","path":"src/Recognizer.lex.tex","sha256":"28bd37cb2876ff04da7a9efddf50a52d3019c64910aca2b806b4b6181e84b04b"},{"byte_length":3686,"kind":"source","path":"src/Session.lex.tex","sha256":"0077c43c5251814a8329dc387538b9d0aafb0780238f61ce60bb245e9a15bbb1"},{"byte_length":6766,"kind":"source","path":"src/Triage.lex.tex","sha256":"61ce4693fcb18df340d1f0f9a9a0d29a73912cc4075bd20dcbda09508373808b"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Models.Flows","module":"Flows","source_path":"src/Flows.lex.tex"},{"lean_module":"Models.Glyphs","module":"Glyphs","source_path":"src/Glyphs.lex.tex"},{"lean_module":"Models.Ledger","module":"Ledger","source_path":"src/Ledger.lex.tex"},{"lean_module":"Models.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Models.Pipeline","module":"Pipeline","source_path":"src/Pipeline.lex.tex"},{"lean_module":"Models.Policy","module":"Policy","source_path":"src/Policy.lex.tex"},{"lean_module":"Models.Recognizer","module":"Recognizer","source_path":"src/Recognizer.lex.tex"},{"lean_module":"Models.Session","module":"Session","source_path":"src/Session.lex.tex"},{"lean_module":"Models.Triage","module":"Triage","source_path":"src/Triage.lex.tex"}],"outputs":[{"byte_length":24217,"kind":"coverage","path":"coverage/Models/Flows.coverage.json","sha256":"e9b1f6037cee26e0cdc097c7bc65ed0345263b1ed4463ed7d210eafaad1adff4"},{"byte_length":9847,"kind":"coverage","path":"coverage/Models/Glyphs.coverage.json","sha256":"072aea809bb4e07810443bd6655b3dbedd5ffc81ee90b3b281013c7dc18f0001"},{"byte_length":25557,"kind":"coverage","path":"coverage/Models/Ledger.coverage.json","sha256":"8029c3cef9485dee7bf5585898f5416186731f9b0ec1df5b5186865278447b01"},{"byte_length":30015,"kind":"coverage","path":"coverage/Models/Main.coverage.json","sha256":"477bcd9b3e0f0d6061de1f0e125668d19ca0a963a869aebd621c4f8361f9d42d"},{"byte_length":24131,"kind":"coverage","path":"coverage/Models/Pipeline.coverage.json","sha256":"e082ea27d2b6e96f9168548252aa12f19153ef34d27b5031617fd7720cbabb88"},{"byte_length":12248,"kind":"coverage","path":"coverage/Models/Policy.coverage.json","sha256":"04dc9b952a28d723f62e3b56b063eddd9953f0aefd29d3897e66bc735ff78445"},{"byte_length":15495,"kind":"coverage","path":"coverage/Models/Recognizer.coverage.json","sha256":"69fdda5a237d1935f7ca26006e6560af6dcbebadb69d17f227a2429866e7cbb9"},{"byte_length":12487,"kind":"coverage","path":"coverage/Models/Session.coverage.json","sha256":"480eff88eec1169a6d701a53c9669598b579ce0699d75c695d043020180095ed"},{"byte_length":13513,"kind":"coverage","path":"coverage/Models/Triage.coverage.json","sha256":"5837a31c1b4d9651670e477b15abfb0c466a57d9b777987c99f059e2b3a02ac5"},{"byte_length":62836,"kind":"lean","path":"modules/Models/Flows.lean","sha256":"871a71c6eed0efaca275f805e9b26dd7eb07d1bbf0d6fccaf65fd0ffcbf61f3e"},{"byte_length":2855,"kind":"lean","path":"modules/Models/Glyphs.lean","sha256":"8aa86a6b8345f27ccbe31ec8e215ccbc41f5a94b80b06b46c9a953e230e2f14c"},{"byte_length":67242,"kind":"lean","path":"modules/Models/Ledger.lean","sha256":"6097dcedded56f40246156dbf0b299695566039e964ca0e1cc1e95641bd9cdac"},{"byte_length":17668,"kind":"lean","path":"modules/Models/Main.lean","sha256":"658e891f7761222d52582f26186d208769621fdabaa1a0309cba849c8f0d0509"},{"byte_length":15495,"kind":"lean","path":"modules/Models/Pipeline.lean","sha256":"0974e254daa6ea324063802ef965309e195c2cadb3ff154a7ecab65e011e2cb1"},{"byte_length":2673,"kind":"lean","path":"modules/Models/Policy.lean","sha256":"75af53ee823cb3b3a8a2fa5518ca4705eaf5cd16ff963e45a936a3bc888f2105"},{"byte_length":25032,"kind":"lean","path":"modules/Models/Recognizer.lean","sha256":"c3c1a25b313cdf4e12d29fad952adf3d0e4fc0c8d8f4c2d4ba6db942e53a3b09"},{"byte_length":15239,"kind":"lean","path":"modules/Models/Session.lean","sha256":"6b3037069b9b123c316c85e9a2126779078ed85ea658a8d04ae4693582185074"},{"byte_length":7179,"kind":"lean","path":"modules/Models/Triage.lean","sha256":"da0208edd92e97b9d9052875c679a7a6954bd41f37497e00ddcf40d47389147b"},{"byte_length":11477,"kind":"lexicon-closure","path":"lexicons/Flows.closure.json","sha256":"858b26caa8a4ba472b9fda1c075790e289bad1bc2c8fd9972ce01c780e1249d5"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Glyphs.closure.json","sha256":"de21ab7949a2df29237c6a4d7f321091f5acd24d46fa1807cdbc0b65f864b27a"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Ledger.closure.json","sha256":"f9388586b5a83a1936fb2a98fc17b01d7cd07e13687d01d5899a3688adb62427"},{"byte_length":11476,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"76718e3e6f6a37d3170b892b6beafe27c8a80a81ff6c957e571441ddcf81b1d6"},{"byte_length":11480,"kind":"lexicon-closure","path":"lexicons/Pipeline.closure.json","sha256":"83cdbac593b6281d194e892e8c635551073cd5113cf47b84e4aa8dc3165cb4ae"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Policy.closure.json","sha256":"cfea6fccd554628e92aa4e4ab9501276443605e9b7b7222894a9345acdeeaf5c"},{"byte_length":11482,"kind":"lexicon-closure","path":"lexicons/Recognizer.closure.json","sha256":"9297441e84743784deedc603cbc74d71441164d59f788c3b6c0e7bbb3ac6e2a8"},{"byte_length":11479,"kind":"lexicon-closure","path":"lexicons/Session.closure.json","sha256":"8300e307091b03c0b18bafb8be0a476514693fddaac26c9481b5bec9bc1908f8"},{"byte_length":11478,"kind":"lexicon-closure","path":"lexicons/Triage.closure.json","sha256":"b2f32bd383076cd4db64bfbc67ef975f94d237edb76f59a156317639270e482f"},{"byte_length":19292,"kind":"map","path":"maps/Models/Flows.map.json","sha256":"940583ea24b19ccba35d62d8dd047ac9d5bf53782d809d728b4cad075cf6b318"},{"byte_length":2945,"kind":"map","path":"maps/Models/Glyphs.map.json","sha256":"79b7da8f356b211b39fdba29daf4b8f014e0941671516d7a8ba408ed9d52666e"},{"byte_length":21594,"kind":"map","path":"maps/Models/Ledger.map.json","sha256":"925504d898b13bac4a0157b6dd5c7cff923a68ad75d09d17be17569445d4ef5f"},{"byte_length":21960,"kind":"map","path":"maps/Models/Main.map.json","sha256":"931fb5c17684ac7b1584cfe007a2efa8dba120b0aa8d767e5376f5fe7fe5d885"},{"byte_length":15952,"kind":"map","path":"maps/Models/Pipeline.map.json","sha256":"e8f625b074758785668941fb56f24db011c16f17fb95feafc5f6b869a8af4193"},{"byte_length":4862,"kind":"map","path":"maps/Models/Policy.map.json","sha256":"7cbb9f501f0b7cfdc779e4c45686a684236b43b4391547bd59a9c54d41d9b97a"},{"byte_length":8484,"kind":"map","path":"maps/Models/Recognizer.map.json","sha256":"fa5850a1f861dc61374daa9673a7995e334fdd72360d6cc2b546311047d0249c"},{"byte_length":5833,"kind":"map","path":"maps/Models/Session.map.json","sha256":"9f137acaaf2f126775dc252f790feb386da35d9dc99b19e4065b1f930ea8d9f1"},{"byte_length":7133,"kind":"map","path":"maps/Models/Triage.map.json","sha256":"27ccaf0a9474418d2c9a551cef5456ec6006d51d5518b92cdc93cefc9eb6103f"},{"byte_length":79615,"kind":"production-eligibility","path":"production/Models/Main.eligibility.json","sha256":"e65c147e2755a7f0140521b73588e6e206590c70f8d3c313a6b13be2420dd3b8"},{"byte_length":37412,"kind":"tex","path":"modules/Models/Flows.tex","sha256":"a7ad124df989dba8e1e5d673c9cc40e6d4b9b5f2a66821d04dc0cbc5ce3bb174"},{"byte_length":4181,"kind":"tex","path":"modules/Models/Glyphs.tex","sha256":"6996f9482d5460c45ac62c9cd8bbe44b376ad98661730c898501535ca39ef537"},{"byte_length":32582,"kind":"tex","path":"modules/Models/Ledger.tex","sha256":"86863d003899b6037aab9ed859608ac66c19ca0f594b2e363577e9cd8c8bae65"},{"byte_length":22675,"kind":"tex","path":"modules/Models/Main.tex","sha256":"99c225ea6da22156c56975a427fb5529abe3b64087760d5962c94a929228b17b"},{"byte_length":22804,"kind":"tex","path":"modules/Models/Pipeline.tex","sha256":"8afd93d17cfb93d15d0a453f85434722a713b25c57ee79637885d6a43bfa1a57"},{"byte_length":5668,"kind":"tex","path":"modules/Models/Policy.tex","sha256":"9b896db44315af8db6859dcb061178eef227967f4835c897f47bd5df85b7649d"},{"byte_length":18868,"kind":"tex","path":"modules/Models/Recognizer.tex","sha256":"4fda5d8ad4890ae385da68c4be4c23b44a5e021869b92e6c599469bfde00e1ba"},{"byte_length":7934,"kind":"tex","path":"modules/Models/Session.tex","sha256":"bdee6203c11a7e19bbcb0cbc81c785c5c8168dc450c4f167215e2d2f4a19dd14"},{"byte_length":11815,"kind":"tex","path":"modules/Models/Triage.tex","sha256":"37fe90aac05faee917c08a1ff9faa63403cf7e42459bad80798152739099b827"}],"project":"models","selection":["Flows","Glyphs","Ledger","Main","Pipeline","Policy","Recognizer","Session","Triage"],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","spec":"lexlean/build-manifest/1"} diff --git a/examples/models/expected/build/maps/Models/Flows.map.json b/examples/models/expected/build/maps/Models/Flows.map.json index 20a63b403..aea06f827 100644 --- a/examples/models/expected/build/maps/Models/Flows.map.json +++ b/examples/models/expected/build/maps/Models/Flows.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Flows.lean"},{"id":1,"kind":"tex","path":"modules/Models/Flows.tex"}],"mappings":[{"artifact":0,"gen_end":372,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":0,"gen_end":538,"gen_start":372,"node":1,"role":"declaration","source":0,"src_end":382,"src_start":160},{"artifact":0,"gen_end":695,"gen_start":538,"node":2,"role":"declaration","source":0,"src_end":694,"src_start":384},{"artifact":0,"gen_end":1312,"gen_start":695,"node":3,"role":"declaration","source":0,"src_end":1026,"src_start":696},{"artifact":0,"gen_end":4373,"gen_start":1312,"node":4,"role":"declaration","source":0,"src_end":1207,"src_start":1028},{"artifact":0,"gen_end":4613,"gen_start":4373,"node":5,"role":"declaration","source":0,"src_end":1331,"src_start":1209},{"artifact":0,"gen_end":4779,"gen_start":4613,"node":6,"role":"declaration","source":0,"src_end":1555,"src_start":1333},{"artifact":0,"gen_end":4944,"gen_start":4779,"node":7,"role":"declaration","source":0,"src_end":1846,"src_start":1557},{"artifact":0,"gen_end":5382,"gen_start":4944,"node":8,"role":"declaration","source":0,"src_end":2107,"src_start":1848},{"artifact":0,"gen_end":8437,"gen_start":5382,"node":9,"role":"declaration","source":0,"src_end":2284,"src_start":2109},{"artifact":0,"gen_end":11493,"gen_start":8437,"node":10,"role":"declaration","source":0,"src_end":2462,"src_start":2286},{"artifact":0,"gen_end":11632,"gen_start":11493,"node":11,"role":"declaration","source":0,"src_end":2619,"src_start":2464},{"artifact":0,"gen_end":12073,"gen_start":11632,"node":12,"role":"declaration","source":0,"src_end":2883,"src_start":2621},{"artifact":0,"gen_end":12220,"gen_start":12073,"node":13,"role":"declaration","source":0,"src_end":3048,"src_start":2885},{"artifact":0,"gen_end":12329,"gen_start":12220,"node":14,"role":"declaration","source":0,"src_end":3165,"src_start":3050},{"artifact":0,"gen_end":12441,"gen_start":12329,"node":15,"role":"declaration","source":0,"src_end":3308,"src_start":3167},{"artifact":0,"gen_end":15479,"gen_start":12441,"node":16,"role":"declaration","source":0,"src_end":3507,"src_start":3310},{"artifact":0,"gen_end":15636,"gen_start":15479,"node":17,"role":"declaration","source":0,"src_end":3783,"src_start":3509},{"artifact":0,"gen_end":16767,"gen_start":15636,"node":18,"role":"declaration","source":0,"src_end":4022,"src_start":3785},{"artifact":0,"gen_end":16908,"gen_start":16767,"node":19,"role":"declaration","source":0,"src_end":4138,"src_start":4024},{"artifact":0,"gen_end":17016,"gen_start":16908,"node":20,"role":"declaration","source":0,"src_end":4257,"src_start":4140},{"artifact":0,"gen_end":17123,"gen_start":17016,"node":21,"role":"declaration","source":0,"src_end":4406,"src_start":4259},{"artifact":0,"gen_end":20251,"gen_start":17123,"node":22,"role":"declaration","source":0,"src_end":4684,"src_start":4408},{"artifact":0,"gen_end":20350,"gen_start":20251,"node":23,"role":"declaration","source":0,"src_end":4784,"src_start":4686},{"artifact":0,"gen_end":20452,"gen_start":20350,"node":24,"role":"declaration","source":0,"src_end":4920,"src_start":4786},{"artifact":0,"gen_end":23544,"gen_start":20452,"node":25,"role":"declaration","source":0,"src_end":5161,"src_start":4922},{"artifact":0,"gen_end":23881,"gen_start":23544,"node":26,"role":"declaration","source":0,"src_end":5584,"src_start":5163},{"artifact":0,"gen_end":24458,"gen_start":23881,"node":27,"role":"declaration","source":0,"src_end":5869,"src_start":5586},{"artifact":0,"gen_end":27578,"gen_start":24458,"node":28,"role":"declaration","source":0,"src_end":6111,"src_start":5871},{"artifact":0,"gen_end":30701,"gen_start":27578,"node":29,"role":"declaration","source":0,"src_end":6355,"src_start":6113},{"artifact":0,"gen_end":30973,"gen_start":30701,"node":30,"role":"declaration","source":0,"src_end":6502,"src_start":6357},{"artifact":0,"gen_end":31115,"gen_start":30973,"node":31,"role":"declaration","source":0,"src_end":6654,"src_start":6504},{"artifact":0,"gen_end":31300,"gen_start":31115,"node":32,"role":"declaration","source":0,"src_end":6856,"src_start":6656},{"artifact":0,"gen_end":34401,"gen_start":31300,"node":33,"role":"declaration","source":0,"src_end":7135,"src_start":6858},{"artifact":0,"gen_end":34575,"gen_start":34401,"node":34,"role":"declaration","source":0,"src_end":7477,"src_start":7137},{"artifact":0,"gen_end":35173,"gen_start":34575,"node":35,"role":"declaration","source":0,"src_end":7770,"src_start":7479},{"artifact":0,"gen_end":38275,"gen_start":35173,"node":36,"role":"declaration","source":0,"src_end":8021,"src_start":7772},{"artifact":0,"gen_end":41378,"gen_start":38275,"node":37,"role":"declaration","source":0,"src_end":8274,"src_start":8023},{"artifact":0,"gen_end":41673,"gen_start":41378,"node":38,"role":"declaration","source":0,"src_end":8430,"src_start":8276},{"artifact":0,"gen_end":42014,"gen_start":41673,"node":39,"role":"declaration","source":0,"src_end":8847,"src_start":8432},{"artifact":0,"gen_end":42621,"gen_start":42014,"node":40,"role":"declaration","source":0,"src_end":9167,"src_start":8849},{"artifact":0,"gen_end":45775,"gen_start":42621,"node":41,"role":"declaration","source":0,"src_end":9435,"src_start":9169},{"artifact":0,"gen_end":48932,"gen_start":45775,"node":42,"role":"declaration","source":0,"src_end":9705,"src_start":9437},{"artifact":0,"gen_end":49197,"gen_start":48932,"node":43,"role":"declaration","source":0,"src_end":9861,"src_start":9707},{"artifact":0,"gen_end":49536,"gen_start":49197,"node":44,"role":"declaration","source":0,"src_end":10304,"src_start":9863},{"artifact":0,"gen_end":52767,"gen_start":49536,"node":45,"role":"declaration","source":0,"src_end":10643,"src_start":10306},{"artifact":0,"gen_end":53429,"gen_start":52767,"node":46,"role":"declaration","source":0,"src_end":11008,"src_start":10645},{"artifact":0,"gen_end":56555,"gen_start":53429,"node":47,"role":"declaration","source":0,"src_end":11256,"src_start":11010},{"artifact":0,"gen_end":59686,"gen_start":56555,"node":48,"role":"declaration","source":0,"src_end":11507,"src_start":11258},{"artifact":0,"gen_end":59973,"gen_start":59686,"node":49,"role":"declaration","source":0,"src_end":11670,"src_start":11509},{"artifact":0,"gen_end":60146,"gen_start":59973,"node":50,"role":"declaration","source":0,"src_end":11992,"src_start":11672},{"artifact":0,"gen_end":61165,"gen_start":60146,"node":51,"role":"declaration","source":0,"src_end":12342,"src_start":11994},{"artifact":0,"gen_end":61464,"gen_start":61165,"node":52,"role":"declaration","source":0,"src_end":12454,"src_start":12344},{"artifact":0,"gen_end":61627,"gen_start":61464,"node":53,"role":"declaration","source":0,"src_end":12660,"src_start":12456},{"artifact":0,"gen_end":61831,"gen_start":61627,"node":54,"role":"declaration","source":0,"src_end":12757,"src_start":12662},{"artifact":0,"gen_end":62521,"gen_start":61831,"node":55,"role":"declaration","source":0,"src_end":13099,"src_start":12759},{"artifact":0,"gen_end":62818,"gen_start":62521,"node":56,"role":"declaration","source":0,"src_end":13210,"src_start":13101},{"artifact":0,"gen_end":62836,"gen_start":62818,"node":0,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":57,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":1,"gen_end":419,"gen_start":134,"node":58,"role":"declaration","source":0,"src_end":382,"src_start":160},{"artifact":1,"gen_end":1149,"gen_start":419,"node":59,"role":"declaration","source":0,"src_end":694,"src_start":384},{"artifact":1,"gen_end":2244,"gen_start":1149,"node":60,"role":"declaration","source":0,"src_end":1026,"src_start":696},{"artifact":1,"gen_end":2506,"gen_start":2244,"node":61,"role":"declaration","source":0,"src_end":1207,"src_start":1028},{"artifact":1,"gen_end":3308,"gen_start":2506,"node":62,"role":"declaration","source":0,"src_end":1331,"src_start":1209},{"artifact":1,"gen_end":3593,"gen_start":3308,"node":63,"role":"declaration","source":0,"src_end":1555,"src_start":1333},{"artifact":1,"gen_end":4331,"gen_start":3593,"node":64,"role":"declaration","source":0,"src_end":1846,"src_start":1557},{"artifact":1,"gen_end":5191,"gen_start":4331,"node":65,"role":"declaration","source":0,"src_end":2107,"src_start":1848},{"artifact":1,"gen_end":5449,"gen_start":5191,"node":66,"role":"declaration","source":0,"src_end":2284,"src_start":2109},{"artifact":1,"gen_end":5708,"gen_start":5449,"node":67,"role":"declaration","source":0,"src_end":2462,"src_start":2286},{"artifact":1,"gen_end":6592,"gen_start":5708,"node":68,"role":"declaration","source":0,"src_end":2619,"src_start":2464},{"artifact":1,"gen_end":7458,"gen_start":6592,"node":69,"role":"declaration","source":0,"src_end":2883,"src_start":2621},{"artifact":1,"gen_end":8366,"gen_start":7458,"node":70,"role":"declaration","source":0,"src_end":3048,"src_start":2885},{"artifact":1,"gen_end":8646,"gen_start":8366,"node":71,"role":"declaration","source":0,"src_end":3165,"src_start":3050},{"artifact":1,"gen_end":9005,"gen_start":8646,"node":72,"role":"declaration","source":0,"src_end":3308,"src_start":3167},{"artifact":1,"gen_end":9264,"gen_start":9005,"node":73,"role":"declaration","source":0,"src_end":3507,"src_start":3310},{"artifact":1,"gen_end":9944,"gen_start":9264,"node":74,"role":"declaration","source":0,"src_end":3783,"src_start":3509},{"artifact":1,"gen_end":11530,"gen_start":9944,"node":75,"role":"declaration","source":0,"src_end":4022,"src_start":3785},{"artifact":1,"gen_end":11997,"gen_start":11530,"node":76,"role":"declaration","source":0,"src_end":4138,"src_start":4024},{"artifact":1,"gen_end":12276,"gen_start":11997,"node":77,"role":"declaration","source":0,"src_end":4257,"src_start":4140},{"artifact":1,"gen_end":12630,"gen_start":12276,"node":78,"role":"declaration","source":0,"src_end":4406,"src_start":4259},{"artifact":1,"gen_end":12917,"gen_start":12630,"node":79,"role":"declaration","source":0,"src_end":4684,"src_start":4408},{"artifact":1,"gen_end":13186,"gen_start":12917,"node":80,"role":"declaration","source":0,"src_end":4784,"src_start":4686},{"artifact":1,"gen_end":13534,"gen_start":13186,"node":81,"role":"declaration","source":0,"src_end":4920,"src_start":4786},{"artifact":1,"gen_end":13836,"gen_start":13534,"node":82,"role":"declaration","source":0,"src_end":5161,"src_start":4922},{"artifact":1,"gen_end":15047,"gen_start":13836,"node":83,"role":"declaration","source":0,"src_end":5584,"src_start":5163},{"artifact":1,"gen_end":16099,"gen_start":15047,"node":84,"role":"declaration","source":0,"src_end":5869,"src_start":5586},{"artifact":1,"gen_end":16399,"gen_start":16099,"node":85,"role":"declaration","source":0,"src_end":6111,"src_start":5871},{"artifact":1,"gen_end":16703,"gen_start":16399,"node":86,"role":"declaration","source":0,"src_end":6355,"src_start":6113},{"artifact":1,"gen_end":17832,"gen_start":16703,"node":87,"role":"declaration","source":0,"src_end":6502,"src_start":6357},{"artifact":1,"gen_end":18160,"gen_start":17832,"node":88,"role":"declaration","source":0,"src_end":6654,"src_start":6504},{"artifact":1,"gen_end":18592,"gen_start":18160,"node":89,"role":"declaration","source":0,"src_end":6856,"src_start":6656},{"artifact":1,"gen_end":18909,"gen_start":18592,"node":90,"role":"declaration","source":0,"src_end":7135,"src_start":6858},{"artifact":1,"gen_end":19684,"gen_start":18909,"node":91,"role":"declaration","source":0,"src_end":7477,"src_start":7137},{"artifact":1,"gen_end":20771,"gen_start":19684,"node":92,"role":"declaration","source":0,"src_end":7770,"src_start":7479},{"artifact":1,"gen_end":21086,"gen_start":20771,"node":93,"role":"declaration","source":0,"src_end":8021,"src_start":7772},{"artifact":1,"gen_end":21402,"gen_start":21086,"node":94,"role":"declaration","source":0,"src_end":8274,"src_start":8023},{"artifact":1,"gen_end":22540,"gen_start":21402,"node":95,"role":"declaration","source":0,"src_end":8430,"src_start":8276},{"artifact":1,"gen_end":23742,"gen_start":22540,"node":96,"role":"declaration","source":0,"src_end":8847,"src_start":8432},{"artifact":1,"gen_end":24827,"gen_start":23742,"node":97,"role":"declaration","source":0,"src_end":9167,"src_start":8849},{"artifact":1,"gen_end":25161,"gen_start":24827,"node":98,"role":"declaration","source":0,"src_end":9435,"src_start":9169},{"artifact":1,"gen_end":25499,"gen_start":25161,"node":99,"role":"declaration","source":0,"src_end":9705,"src_start":9437},{"artifact":1,"gen_end":26702,"gen_start":25499,"node":100,"role":"declaration","source":0,"src_end":9861,"src_start":9707},{"artifact":1,"gen_end":27930,"gen_start":26702,"node":101,"role":"declaration","source":0,"src_end":10304,"src_start":9863},{"artifact":1,"gen_end":28295,"gen_start":27930,"node":102,"role":"declaration","source":0,"src_end":10643,"src_start":10306},{"artifact":1,"gen_end":29759,"gen_start":28295,"node":103,"role":"declaration","source":0,"src_end":11008,"src_start":10645},{"artifact":1,"gen_end":30065,"gen_start":29759,"node":104,"role":"declaration","source":0,"src_end":11256,"src_start":11010},{"artifact":1,"gen_end":30377,"gen_start":30065,"node":105,"role":"declaration","source":0,"src_end":11507,"src_start":11258},{"artifact":1,"gen_end":31554,"gen_start":30377,"node":106,"role":"declaration","source":0,"src_end":11670,"src_start":11509},{"artifact":1,"gen_end":32296,"gen_start":31554,"node":107,"role":"declaration","source":0,"src_end":11992,"src_start":11672},{"artifact":1,"gen_end":33838,"gen_start":32296,"node":108,"role":"declaration","source":0,"src_end":12342,"src_start":11994},{"artifact":1,"gen_end":34491,"gen_start":33838,"node":109,"role":"declaration","source":0,"src_end":12454,"src_start":12344},{"artifact":1,"gen_end":35046,"gen_start":34491,"node":110,"role":"declaration","source":0,"src_end":12660,"src_start":12456},{"artifact":1,"gen_end":35580,"gen_start":35046,"node":111,"role":"declaration","source":0,"src_end":12757,"src_start":12662},{"artifact":1,"gen_end":36747,"gen_start":35580,"node":112,"role":"declaration","source":0,"src_end":13099,"src_start":12759},{"artifact":1,"gen_end":37397,"gen_start":36747,"node":113,"role":"declaration","source":0,"src_end":13210,"src_start":13101},{"artifact":1,"gen_end":37412,"gen_start":37397,"node":57,"role":"declaration","source":0,"src_end":13246,"src_start":0}],"module":"Flows","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-latex-module"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Flows.lex.tex","sha256":"28ec74d66a4db50353250e50c656dd75d6e0555eaacc19fbd37c573f8e938c33"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Flows.lean"},{"id":1,"kind":"tex","path":"modules/Models/Flows.tex"}],"mappings":[{"artifact":0,"gen_end":372,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":0,"gen_end":538,"gen_start":372,"node":1,"role":"declaration","source":0,"src_end":382,"src_start":160},{"artifact":0,"gen_end":695,"gen_start":538,"node":2,"role":"declaration","source":0,"src_end":694,"src_start":384},{"artifact":0,"gen_end":1312,"gen_start":695,"node":3,"role":"declaration","source":0,"src_end":1026,"src_start":696},{"artifact":0,"gen_end":4373,"gen_start":1312,"node":4,"role":"declaration","source":0,"src_end":1207,"src_start":1028},{"artifact":0,"gen_end":4613,"gen_start":4373,"node":5,"role":"declaration","source":0,"src_end":1331,"src_start":1209},{"artifact":0,"gen_end":4779,"gen_start":4613,"node":6,"role":"declaration","source":0,"src_end":1555,"src_start":1333},{"artifact":0,"gen_end":4944,"gen_start":4779,"node":7,"role":"declaration","source":0,"src_end":1846,"src_start":1557},{"artifact":0,"gen_end":5382,"gen_start":4944,"node":8,"role":"declaration","source":0,"src_end":2107,"src_start":1848},{"artifact":0,"gen_end":8437,"gen_start":5382,"node":9,"role":"declaration","source":0,"src_end":2284,"src_start":2109},{"artifact":0,"gen_end":11493,"gen_start":8437,"node":10,"role":"declaration","source":0,"src_end":2462,"src_start":2286},{"artifact":0,"gen_end":11632,"gen_start":11493,"node":11,"role":"declaration","source":0,"src_end":2619,"src_start":2464},{"artifact":0,"gen_end":12073,"gen_start":11632,"node":12,"role":"declaration","source":0,"src_end":2883,"src_start":2621},{"artifact":0,"gen_end":12220,"gen_start":12073,"node":13,"role":"declaration","source":0,"src_end":3048,"src_start":2885},{"artifact":0,"gen_end":12329,"gen_start":12220,"node":14,"role":"declaration","source":0,"src_end":3165,"src_start":3050},{"artifact":0,"gen_end":12441,"gen_start":12329,"node":15,"role":"declaration","source":0,"src_end":3308,"src_start":3167},{"artifact":0,"gen_end":15479,"gen_start":12441,"node":16,"role":"declaration","source":0,"src_end":3507,"src_start":3310},{"artifact":0,"gen_end":15636,"gen_start":15479,"node":17,"role":"declaration","source":0,"src_end":3783,"src_start":3509},{"artifact":0,"gen_end":16767,"gen_start":15636,"node":18,"role":"declaration","source":0,"src_end":4022,"src_start":3785},{"artifact":0,"gen_end":16908,"gen_start":16767,"node":19,"role":"declaration","source":0,"src_end":4138,"src_start":4024},{"artifact":0,"gen_end":17016,"gen_start":16908,"node":20,"role":"declaration","source":0,"src_end":4257,"src_start":4140},{"artifact":0,"gen_end":17123,"gen_start":17016,"node":21,"role":"declaration","source":0,"src_end":4406,"src_start":4259},{"artifact":0,"gen_end":20251,"gen_start":17123,"node":22,"role":"declaration","source":0,"src_end":4684,"src_start":4408},{"artifact":0,"gen_end":20350,"gen_start":20251,"node":23,"role":"declaration","source":0,"src_end":4784,"src_start":4686},{"artifact":0,"gen_end":20452,"gen_start":20350,"node":24,"role":"declaration","source":0,"src_end":4920,"src_start":4786},{"artifact":0,"gen_end":23544,"gen_start":20452,"node":25,"role":"declaration","source":0,"src_end":5161,"src_start":4922},{"artifact":0,"gen_end":23881,"gen_start":23544,"node":26,"role":"declaration","source":0,"src_end":5584,"src_start":5163},{"artifact":0,"gen_end":24458,"gen_start":23881,"node":27,"role":"declaration","source":0,"src_end":5869,"src_start":5586},{"artifact":0,"gen_end":27578,"gen_start":24458,"node":28,"role":"declaration","source":0,"src_end":6111,"src_start":5871},{"artifact":0,"gen_end":30701,"gen_start":27578,"node":29,"role":"declaration","source":0,"src_end":6355,"src_start":6113},{"artifact":0,"gen_end":30973,"gen_start":30701,"node":30,"role":"declaration","source":0,"src_end":6502,"src_start":6357},{"artifact":0,"gen_end":31115,"gen_start":30973,"node":31,"role":"declaration","source":0,"src_end":6654,"src_start":6504},{"artifact":0,"gen_end":31300,"gen_start":31115,"node":32,"role":"declaration","source":0,"src_end":6856,"src_start":6656},{"artifact":0,"gen_end":34401,"gen_start":31300,"node":33,"role":"declaration","source":0,"src_end":7135,"src_start":6858},{"artifact":0,"gen_end":34575,"gen_start":34401,"node":34,"role":"declaration","source":0,"src_end":7477,"src_start":7137},{"artifact":0,"gen_end":35173,"gen_start":34575,"node":35,"role":"declaration","source":0,"src_end":7770,"src_start":7479},{"artifact":0,"gen_end":38275,"gen_start":35173,"node":36,"role":"declaration","source":0,"src_end":8021,"src_start":7772},{"artifact":0,"gen_end":41378,"gen_start":38275,"node":37,"role":"declaration","source":0,"src_end":8274,"src_start":8023},{"artifact":0,"gen_end":41673,"gen_start":41378,"node":38,"role":"declaration","source":0,"src_end":8430,"src_start":8276},{"artifact":0,"gen_end":42014,"gen_start":41673,"node":39,"role":"declaration","source":0,"src_end":8847,"src_start":8432},{"artifact":0,"gen_end":42621,"gen_start":42014,"node":40,"role":"declaration","source":0,"src_end":9167,"src_start":8849},{"artifact":0,"gen_end":45775,"gen_start":42621,"node":41,"role":"declaration","source":0,"src_end":9435,"src_start":9169},{"artifact":0,"gen_end":48932,"gen_start":45775,"node":42,"role":"declaration","source":0,"src_end":9705,"src_start":9437},{"artifact":0,"gen_end":49197,"gen_start":48932,"node":43,"role":"declaration","source":0,"src_end":9861,"src_start":9707},{"artifact":0,"gen_end":49536,"gen_start":49197,"node":44,"role":"declaration","source":0,"src_end":10304,"src_start":9863},{"artifact":0,"gen_end":52767,"gen_start":49536,"node":45,"role":"declaration","source":0,"src_end":10643,"src_start":10306},{"artifact":0,"gen_end":53429,"gen_start":52767,"node":46,"role":"declaration","source":0,"src_end":11008,"src_start":10645},{"artifact":0,"gen_end":56555,"gen_start":53429,"node":47,"role":"declaration","source":0,"src_end":11256,"src_start":11010},{"artifact":0,"gen_end":59686,"gen_start":56555,"node":48,"role":"declaration","source":0,"src_end":11507,"src_start":11258},{"artifact":0,"gen_end":59973,"gen_start":59686,"node":49,"role":"declaration","source":0,"src_end":11670,"src_start":11509},{"artifact":0,"gen_end":60146,"gen_start":59973,"node":50,"role":"declaration","source":0,"src_end":11992,"src_start":11672},{"artifact":0,"gen_end":61165,"gen_start":60146,"node":51,"role":"declaration","source":0,"src_end":12342,"src_start":11994},{"artifact":0,"gen_end":61464,"gen_start":61165,"node":52,"role":"declaration","source":0,"src_end":12454,"src_start":12344},{"artifact":0,"gen_end":61627,"gen_start":61464,"node":53,"role":"declaration","source":0,"src_end":12660,"src_start":12456},{"artifact":0,"gen_end":61831,"gen_start":61627,"node":54,"role":"declaration","source":0,"src_end":12757,"src_start":12662},{"artifact":0,"gen_end":62521,"gen_start":61831,"node":55,"role":"declaration","source":0,"src_end":13099,"src_start":12759},{"artifact":0,"gen_end":62818,"gen_start":62521,"node":56,"role":"declaration","source":0,"src_end":13210,"src_start":13101},{"artifact":0,"gen_end":62836,"gen_start":62818,"node":0,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":57,"role":"declaration","source":0,"src_end":13246,"src_start":0},{"artifact":1,"gen_end":419,"gen_start":134,"node":58,"role":"declaration","source":0,"src_end":382,"src_start":160},{"artifact":1,"gen_end":1149,"gen_start":419,"node":59,"role":"declaration","source":0,"src_end":694,"src_start":384},{"artifact":1,"gen_end":2244,"gen_start":1149,"node":60,"role":"declaration","source":0,"src_end":1026,"src_start":696},{"artifact":1,"gen_end":2506,"gen_start":2244,"node":61,"role":"declaration","source":0,"src_end":1207,"src_start":1028},{"artifact":1,"gen_end":3308,"gen_start":2506,"node":62,"role":"declaration","source":0,"src_end":1331,"src_start":1209},{"artifact":1,"gen_end":3593,"gen_start":3308,"node":63,"role":"declaration","source":0,"src_end":1555,"src_start":1333},{"artifact":1,"gen_end":4331,"gen_start":3593,"node":64,"role":"declaration","source":0,"src_end":1846,"src_start":1557},{"artifact":1,"gen_end":5191,"gen_start":4331,"node":65,"role":"declaration","source":0,"src_end":2107,"src_start":1848},{"artifact":1,"gen_end":5449,"gen_start":5191,"node":66,"role":"declaration","source":0,"src_end":2284,"src_start":2109},{"artifact":1,"gen_end":5708,"gen_start":5449,"node":67,"role":"declaration","source":0,"src_end":2462,"src_start":2286},{"artifact":1,"gen_end":6592,"gen_start":5708,"node":68,"role":"declaration","source":0,"src_end":2619,"src_start":2464},{"artifact":1,"gen_end":7458,"gen_start":6592,"node":69,"role":"declaration","source":0,"src_end":2883,"src_start":2621},{"artifact":1,"gen_end":8366,"gen_start":7458,"node":70,"role":"declaration","source":0,"src_end":3048,"src_start":2885},{"artifact":1,"gen_end":8646,"gen_start":8366,"node":71,"role":"declaration","source":0,"src_end":3165,"src_start":3050},{"artifact":1,"gen_end":9005,"gen_start":8646,"node":72,"role":"declaration","source":0,"src_end":3308,"src_start":3167},{"artifact":1,"gen_end":9264,"gen_start":9005,"node":73,"role":"declaration","source":0,"src_end":3507,"src_start":3310},{"artifact":1,"gen_end":9944,"gen_start":9264,"node":74,"role":"declaration","source":0,"src_end":3783,"src_start":3509},{"artifact":1,"gen_end":11530,"gen_start":9944,"node":75,"role":"declaration","source":0,"src_end":4022,"src_start":3785},{"artifact":1,"gen_end":11997,"gen_start":11530,"node":76,"role":"declaration","source":0,"src_end":4138,"src_start":4024},{"artifact":1,"gen_end":12276,"gen_start":11997,"node":77,"role":"declaration","source":0,"src_end":4257,"src_start":4140},{"artifact":1,"gen_end":12630,"gen_start":12276,"node":78,"role":"declaration","source":0,"src_end":4406,"src_start":4259},{"artifact":1,"gen_end":12917,"gen_start":12630,"node":79,"role":"declaration","source":0,"src_end":4684,"src_start":4408},{"artifact":1,"gen_end":13186,"gen_start":12917,"node":80,"role":"declaration","source":0,"src_end":4784,"src_start":4686},{"artifact":1,"gen_end":13534,"gen_start":13186,"node":81,"role":"declaration","source":0,"src_end":4920,"src_start":4786},{"artifact":1,"gen_end":13836,"gen_start":13534,"node":82,"role":"declaration","source":0,"src_end":5161,"src_start":4922},{"artifact":1,"gen_end":15047,"gen_start":13836,"node":83,"role":"declaration","source":0,"src_end":5584,"src_start":5163},{"artifact":1,"gen_end":16099,"gen_start":15047,"node":84,"role":"declaration","source":0,"src_end":5869,"src_start":5586},{"artifact":1,"gen_end":16399,"gen_start":16099,"node":85,"role":"declaration","source":0,"src_end":6111,"src_start":5871},{"artifact":1,"gen_end":16703,"gen_start":16399,"node":86,"role":"declaration","source":0,"src_end":6355,"src_start":6113},{"artifact":1,"gen_end":17832,"gen_start":16703,"node":87,"role":"declaration","source":0,"src_end":6502,"src_start":6357},{"artifact":1,"gen_end":18160,"gen_start":17832,"node":88,"role":"declaration","source":0,"src_end":6654,"src_start":6504},{"artifact":1,"gen_end":18592,"gen_start":18160,"node":89,"role":"declaration","source":0,"src_end":6856,"src_start":6656},{"artifact":1,"gen_end":18909,"gen_start":18592,"node":90,"role":"declaration","source":0,"src_end":7135,"src_start":6858},{"artifact":1,"gen_end":19684,"gen_start":18909,"node":91,"role":"declaration","source":0,"src_end":7477,"src_start":7137},{"artifact":1,"gen_end":20771,"gen_start":19684,"node":92,"role":"declaration","source":0,"src_end":7770,"src_start":7479},{"artifact":1,"gen_end":21086,"gen_start":20771,"node":93,"role":"declaration","source":0,"src_end":8021,"src_start":7772},{"artifact":1,"gen_end":21402,"gen_start":21086,"node":94,"role":"declaration","source":0,"src_end":8274,"src_start":8023},{"artifact":1,"gen_end":22540,"gen_start":21402,"node":95,"role":"declaration","source":0,"src_end":8430,"src_start":8276},{"artifact":1,"gen_end":23742,"gen_start":22540,"node":96,"role":"declaration","source":0,"src_end":8847,"src_start":8432},{"artifact":1,"gen_end":24827,"gen_start":23742,"node":97,"role":"declaration","source":0,"src_end":9167,"src_start":8849},{"artifact":1,"gen_end":25161,"gen_start":24827,"node":98,"role":"declaration","source":0,"src_end":9435,"src_start":9169},{"artifact":1,"gen_end":25499,"gen_start":25161,"node":99,"role":"declaration","source":0,"src_end":9705,"src_start":9437},{"artifact":1,"gen_end":26702,"gen_start":25499,"node":100,"role":"declaration","source":0,"src_end":9861,"src_start":9707},{"artifact":1,"gen_end":27930,"gen_start":26702,"node":101,"role":"declaration","source":0,"src_end":10304,"src_start":9863},{"artifact":1,"gen_end":28295,"gen_start":27930,"node":102,"role":"declaration","source":0,"src_end":10643,"src_start":10306},{"artifact":1,"gen_end":29759,"gen_start":28295,"node":103,"role":"declaration","source":0,"src_end":11008,"src_start":10645},{"artifact":1,"gen_end":30065,"gen_start":29759,"node":104,"role":"declaration","source":0,"src_end":11256,"src_start":11010},{"artifact":1,"gen_end":30377,"gen_start":30065,"node":105,"role":"declaration","source":0,"src_end":11507,"src_start":11258},{"artifact":1,"gen_end":31554,"gen_start":30377,"node":106,"role":"declaration","source":0,"src_end":11670,"src_start":11509},{"artifact":1,"gen_end":32296,"gen_start":31554,"node":107,"role":"declaration","source":0,"src_end":11992,"src_start":11672},{"artifact":1,"gen_end":33838,"gen_start":32296,"node":108,"role":"declaration","source":0,"src_end":12342,"src_start":11994},{"artifact":1,"gen_end":34491,"gen_start":33838,"node":109,"role":"declaration","source":0,"src_end":12454,"src_start":12344},{"artifact":1,"gen_end":35046,"gen_start":34491,"node":110,"role":"declaration","source":0,"src_end":12660,"src_start":12456},{"artifact":1,"gen_end":35580,"gen_start":35046,"node":111,"role":"declaration","source":0,"src_end":12757,"src_start":12662},{"artifact":1,"gen_end":36747,"gen_start":35580,"node":112,"role":"declaration","source":0,"src_end":13099,"src_start":12759},{"artifact":1,"gen_end":37397,"gen_start":36747,"node":113,"role":"declaration","source":0,"src_end":13210,"src_start":13101},{"artifact":1,"gen_end":37412,"gen_start":37397,"node":57,"role":"declaration","source":0,"src_end":13246,"src_start":0}],"module":"Flows","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-latex-module"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Flows.lex.tex","sha256":"28ec74d66a4db50353250e50c656dd75d6e0555eaacc19fbd37c573f8e938c33"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Glyphs.map.json b/examples/models/expected/build/maps/Models/Glyphs.map.json index 3f8302b6d..74dd559bc 100644 --- a/examples/models/expected/build/maps/Models/Glyphs.map.json +++ b/examples/models/expected/build/maps/Models/Glyphs.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Glyphs.lean"},{"id":1,"kind":"tex","path":"modules/Models/Glyphs.tex"}],"mappings":[{"artifact":0,"gen_end":234,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":0,"gen_end":334,"gen_start":234,"node":1,"role":"declaration","source":0,"src_end":501,"src_start":132},{"artifact":0,"gen_end":1784,"gen_start":334,"node":2,"role":"declaration","source":0,"src_end":2097,"src_start":503},{"artifact":0,"gen_end":2018,"gen_start":1784,"node":3,"role":"declaration","source":0,"src_end":2417,"src_start":2099},{"artifact":0,"gen_end":2257,"gen_start":2018,"node":4,"role":"declaration","source":0,"src_end":2742,"src_start":2419},{"artifact":0,"gen_end":2531,"gen_start":2257,"node":5,"role":"declaration","source":0,"src_end":3102,"src_start":2744},{"artifact":0,"gen_end":2836,"gen_start":2531,"node":6,"role":"declaration","source":0,"src_end":3885,"src_start":3104},{"artifact":0,"gen_end":2855,"gen_start":2836,"node":0,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":7,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":1,"gen_end":723,"gen_start":134,"node":8,"role":"declaration","source":0,"src_end":501,"src_start":132},{"artifact":1,"gen_end":2420,"gen_start":723,"node":9,"role":"declaration","source":0,"src_end":2097,"src_start":503},{"artifact":1,"gen_end":2901,"gen_start":2420,"node":10,"role":"declaration","source":0,"src_end":2417,"src_start":2099},{"artifact":1,"gen_end":3387,"gen_start":2901,"node":11,"role":"declaration","source":0,"src_end":2742,"src_start":2419},{"artifact":1,"gen_end":3908,"gen_start":3387,"node":12,"role":"declaration","source":0,"src_end":3102,"src_start":2744},{"artifact":1,"gen_end":4166,"gen_start":3908,"node":13,"role":"declaration","source":0,"src_end":3885,"src_start":3104},{"artifact":1,"gen_end":4181,"gen_start":4166,"node":7,"role":"declaration","source":0,"src_end":3921,"src_start":0}],"module":"Glyphs","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-latex-module"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Glyphs.lex.tex","sha256":"14f0f695eb5d2853be86d0599bc52cad41f92c971c4b8b69ac77ddc0635d3b70"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Glyphs.lean"},{"id":1,"kind":"tex","path":"modules/Models/Glyphs.tex"}],"mappings":[{"artifact":0,"gen_end":234,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":0,"gen_end":334,"gen_start":234,"node":1,"role":"declaration","source":0,"src_end":501,"src_start":132},{"artifact":0,"gen_end":1784,"gen_start":334,"node":2,"role":"declaration","source":0,"src_end":2097,"src_start":503},{"artifact":0,"gen_end":2018,"gen_start":1784,"node":3,"role":"declaration","source":0,"src_end":2417,"src_start":2099},{"artifact":0,"gen_end":2257,"gen_start":2018,"node":4,"role":"declaration","source":0,"src_end":2742,"src_start":2419},{"artifact":0,"gen_end":2531,"gen_start":2257,"node":5,"role":"declaration","source":0,"src_end":3102,"src_start":2744},{"artifact":0,"gen_end":2836,"gen_start":2531,"node":6,"role":"declaration","source":0,"src_end":3885,"src_start":3104},{"artifact":0,"gen_end":2855,"gen_start":2836,"node":0,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":7,"role":"declaration","source":0,"src_end":3921,"src_start":0},{"artifact":1,"gen_end":723,"gen_start":134,"node":8,"role":"declaration","source":0,"src_end":501,"src_start":132},{"artifact":1,"gen_end":2420,"gen_start":723,"node":9,"role":"declaration","source":0,"src_end":2097,"src_start":503},{"artifact":1,"gen_end":2901,"gen_start":2420,"node":10,"role":"declaration","source":0,"src_end":2417,"src_start":2099},{"artifact":1,"gen_end":3387,"gen_start":2901,"node":11,"role":"declaration","source":0,"src_end":2742,"src_start":2419},{"artifact":1,"gen_end":3908,"gen_start":3387,"node":12,"role":"declaration","source":0,"src_end":3102,"src_start":2744},{"artifact":1,"gen_end":4166,"gen_start":3908,"node":13,"role":"declaration","source":0,"src_end":3885,"src_start":3104},{"artifact":1,"gen_end":4181,"gen_start":4166,"node":7,"role":"declaration","source":0,"src_end":3921,"src_start":0}],"module":"Glyphs","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-latex-module"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Glyphs.lex.tex","sha256":"14f0f695eb5d2853be86d0599bc52cad41f92c971c4b8b69ac77ddc0635d3b70"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Ledger.map.json b/examples/models/expected/build/maps/Models/Ledger.map.json index 7b455cf23..8f124351a 100644 --- a/examples/models/expected/build/maps/Models/Ledger.map.json +++ b/examples/models/expected/build/maps/Models/Ledger.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Ledger.lean"},{"id":1,"kind":"tex","path":"modules/Models/Ledger.tex"}],"mappings":[{"artifact":0,"gen_end":345,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":0,"gen_end":416,"gen_start":345,"node":1,"role":"declaration","source":0,"src_end":221,"src_start":142},{"artifact":0,"gen_end":490,"gen_start":416,"node":2,"role":"declaration","source":0,"src_end":338,"src_start":223},{"artifact":0,"gen_end":3533,"gen_start":490,"node":3,"role":"declaration","source":0,"src_end":542,"src_start":340},{"artifact":0,"gen_end":6579,"gen_start":3533,"node":4,"role":"declaration","source":0,"src_end":749,"src_start":544},{"artifact":0,"gen_end":6659,"gen_start":6579,"node":5,"role":"declaration","source":0,"src_end":837,"src_start":751},{"artifact":0,"gen_end":6742,"gen_start":6659,"node":6,"role":"declaration","source":0,"src_end":961,"src_start":839},{"artifact":0,"gen_end":9798,"gen_start":6742,"node":7,"role":"declaration","source":0,"src_end":1173,"src_start":963},{"artifact":0,"gen_end":9898,"gen_start":9798,"node":8,"role":"declaration","source":0,"src_end":1288,"src_start":1175},{"artifact":0,"gen_end":10001,"gen_start":9898,"node":9,"role":"declaration","source":0,"src_end":1429,"src_start":1290},{"artifact":0,"gen_end":13093,"gen_start":10001,"node":10,"role":"declaration","source":0,"src_end":1667,"src_start":1431},{"artifact":0,"gen_end":16188,"gen_start":13093,"node":11,"role":"declaration","source":0,"src_end":1908,"src_start":1669},{"artifact":0,"gen_end":17009,"gen_start":16188,"node":12,"role":"declaration","source":0,"src_end":2521,"src_start":1910},{"artifact":0,"gen_end":17140,"gen_start":17009,"node":13,"role":"declaration","source":0,"src_end":2709,"src_start":2523},{"artifact":0,"gen_end":17228,"gen_start":17140,"node":14,"role":"declaration","source":0,"src_end":2840,"src_start":2711},{"artifact":0,"gen_end":20330,"gen_start":17228,"node":15,"role":"declaration","source":0,"src_end":3111,"src_start":2842},{"artifact":0,"gen_end":23405,"gen_start":20330,"node":16,"role":"declaration","source":0,"src_end":3340,"src_start":3113},{"artifact":0,"gen_end":23603,"gen_start":23405,"node":17,"role":"declaration","source":0,"src_end":3532,"src_start":3342},{"artifact":0,"gen_end":23809,"gen_start":23603,"node":18,"role":"declaration","source":0,"src_end":3670,"src_start":3534},{"artifact":0,"gen_end":24020,"gen_start":23809,"node":19,"role":"declaration","source":0,"src_end":3881,"src_start":3672},{"artifact":0,"gen_end":24232,"gen_start":24020,"node":20,"role":"declaration","source":0,"src_end":4023,"src_start":3883},{"artifact":0,"gen_end":24552,"gen_start":24232,"node":21,"role":"declaration","source":0,"src_end":4410,"src_start":4025},{"artifact":0,"gen_end":24683,"gen_start":24552,"node":22,"role":"declaration","source":0,"src_end":4598,"src_start":4412},{"artifact":0,"gen_end":24771,"gen_start":24683,"node":23,"role":"declaration","source":0,"src_end":4729,"src_start":4600},{"artifact":0,"gen_end":27849,"gen_start":24771,"node":24,"role":"declaration","source":0,"src_end":4976,"src_start":4731},{"artifact":0,"gen_end":30908,"gen_start":27849,"node":25,"role":"declaration","source":0,"src_end":5189,"src_start":4978},{"artifact":0,"gen_end":31287,"gen_start":30908,"node":26,"role":"declaration","source":0,"src_end":5464,"src_start":5191},{"artifact":0,"gen_end":31493,"gen_start":31287,"node":27,"role":"declaration","source":0,"src_end":5601,"src_start":5466},{"artifact":0,"gen_end":31975,"gen_start":31493,"node":28,"role":"declaration","source":0,"src_end":6046,"src_start":5603},{"artifact":0,"gen_end":32302,"gen_start":31975,"node":29,"role":"declaration","source":0,"src_end":6382,"src_start":6048},{"artifact":0,"gen_end":32586,"gen_start":32302,"node":30,"role":"declaration","source":0,"src_end":6653,"src_start":6384},{"artifact":0,"gen_end":32656,"gen_start":32586,"node":31,"role":"declaration","source":0,"src_end":6753,"src_start":6655},{"artifact":0,"gen_end":35702,"gen_start":32656,"node":32,"role":"declaration","source":0,"src_end":6973,"src_start":6755},{"artifact":0,"gen_end":38778,"gen_start":35702,"node":33,"role":"declaration","source":0,"src_end":7220,"src_start":6975},{"artifact":0,"gen_end":41834,"gen_start":38778,"node":34,"role":"declaration","source":0,"src_end":7432,"src_start":7222},{"artifact":0,"gen_end":42532,"gen_start":41834,"node":35,"role":"declaration","source":0,"src_end":7803,"src_start":7434},{"artifact":0,"gen_end":42738,"gen_start":42532,"node":36,"role":"declaration","source":0,"src_end":7938,"src_start":7805},{"artifact":0,"gen_end":42898,"gen_start":42738,"node":37,"role":"declaration","source":0,"src_end":8213,"src_start":7940},{"artifact":0,"gen_end":45955,"gen_start":42898,"node":38,"role":"declaration","source":0,"src_end":8441,"src_start":8215},{"artifact":0,"gen_end":49000,"gen_start":45955,"node":39,"role":"declaration","source":0,"src_end":8642,"src_start":8443},{"artifact":0,"gen_end":49337,"gen_start":49000,"node":40,"role":"declaration","source":0,"src_end":8925,"src_start":8644},{"artifact":0,"gen_end":49541,"gen_start":49337,"node":41,"role":"declaration","source":0,"src_end":9059,"src_start":8927},{"artifact":0,"gen_end":49611,"gen_start":49541,"node":42,"role":"declaration","source":0,"src_end":9139,"src_start":9061},{"artifact":0,"gen_end":49684,"gen_start":49611,"node":43,"role":"declaration","source":0,"src_end":9255,"src_start":9141},{"artifact":0,"gen_end":52727,"gen_start":49684,"node":44,"role":"declaration","source":0,"src_end":9459,"src_start":9257},{"artifact":0,"gen_end":55773,"gen_start":52727,"node":45,"role":"declaration","source":0,"src_end":9666,"src_start":9461},{"artifact":0,"gen_end":55851,"gen_start":55773,"node":46,"role":"declaration","source":0,"src_end":9753,"src_start":9668},{"artifact":0,"gen_end":55932,"gen_start":55851,"node":47,"role":"declaration","source":0,"src_end":9876,"src_start":9755},{"artifact":0,"gen_end":58988,"gen_start":55932,"node":48,"role":"declaration","source":0,"src_end":10088,"src_start":9878},{"artifact":0,"gen_end":59482,"gen_start":58988,"node":49,"role":"declaration","source":0,"src_end":10501,"src_start":10090},{"artifact":0,"gen_end":59569,"gen_start":59482,"node":50,"role":"declaration","source":0,"src_end":10659,"src_start":10503},{"artifact":0,"gen_end":59659,"gen_start":59569,"node":51,"role":"declaration","source":0,"src_end":10786,"src_start":10661},{"artifact":0,"gen_end":62697,"gen_start":59659,"node":52,"role":"declaration","source":0,"src_end":10985,"src_start":10788},{"artifact":0,"gen_end":62856,"gen_start":62697,"node":53,"role":"declaration","source":0,"src_end":11166,"src_start":10987},{"artifact":0,"gen_end":62962,"gen_start":62856,"node":54,"role":"declaration","source":0,"src_end":11313,"src_start":11168},{"artifact":0,"gen_end":66038,"gen_start":62962,"node":55,"role":"declaration","source":0,"src_end":11547,"src_start":11315},{"artifact":0,"gen_end":66349,"gen_start":66038,"node":56,"role":"declaration","source":0,"src_end":11857,"src_start":11549},{"artifact":0,"gen_end":66519,"gen_start":66349,"node":57,"role":"declaration","source":0,"src_end":12172,"src_start":11859},{"artifact":0,"gen_end":66607,"gen_start":66519,"node":58,"role":"declaration","source":0,"src_end":12307,"src_start":12174},{"artifact":0,"gen_end":66792,"gen_start":66607,"node":59,"role":"declaration","source":0,"src_end":12519,"src_start":12309},{"artifact":0,"gen_end":66885,"gen_start":66792,"node":60,"role":"declaration","source":0,"src_end":12664,"src_start":12521},{"artifact":0,"gen_end":66944,"gen_start":66885,"node":61,"role":"declaration","source":0,"src_end":12808,"src_start":12666},{"artifact":0,"gen_end":67040,"gen_start":66944,"node":62,"role":"declaration","source":0,"src_end":12906,"src_start":12810},{"artifact":0,"gen_end":67223,"gen_start":67040,"node":63,"role":"declaration","source":0,"src_end":13228,"src_start":12908},{"artifact":0,"gen_end":67242,"gen_start":67223,"node":0,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":64,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":1,"gen_end":376,"gen_start":134,"node":65,"role":"declaration","source":0,"src_end":221,"src_start":142},{"artifact":1,"gen_end":697,"gen_start":376,"node":66,"role":"declaration","source":0,"src_end":338,"src_start":223},{"artifact":1,"gen_end":955,"gen_start":697,"node":67,"role":"declaration","source":0,"src_end":542,"src_start":340},{"artifact":1,"gen_end":1216,"gen_start":955,"node":68,"role":"declaration","source":0,"src_end":749,"src_start":544},{"artifact":1,"gen_end":1466,"gen_start":1216,"node":69,"role":"declaration","source":0,"src_end":837,"src_start":751},{"artifact":1,"gen_end":1795,"gen_start":1466,"node":70,"role":"declaration","source":0,"src_end":961,"src_start":839},{"artifact":1,"gen_end":2068,"gen_start":1795,"node":71,"role":"declaration","source":0,"src_end":1173,"src_start":963},{"artifact":1,"gen_end":2337,"gen_start":2068,"node":72,"role":"declaration","source":0,"src_end":1288,"src_start":1175},{"artifact":1,"gen_end":2685,"gen_start":2337,"node":73,"role":"declaration","source":0,"src_end":1429,"src_start":1290},{"artifact":1,"gen_end":2994,"gen_start":2685,"node":74,"role":"declaration","source":0,"src_end":1667,"src_start":1431},{"artifact":1,"gen_end":3306,"gen_start":2994,"node":75,"role":"declaration","source":0,"src_end":1908,"src_start":1669},{"artifact":1,"gen_end":5595,"gen_start":3306,"node":76,"role":"declaration","source":0,"src_end":2521,"src_start":1910},{"artifact":1,"gen_end":6086,"gen_start":5595,"node":77,"role":"declaration","source":0,"src_end":2709,"src_start":2523},{"artifact":1,"gen_end":6421,"gen_start":6086,"node":78,"role":"declaration","source":0,"src_end":2840,"src_start":2711},{"artifact":1,"gen_end":6741,"gen_start":6421,"node":79,"role":"declaration","source":0,"src_end":3111,"src_start":2842},{"artifact":1,"gen_end":7034,"gen_start":6741,"node":80,"role":"declaration","source":0,"src_end":3340,"src_start":3113},{"artifact":1,"gen_end":7716,"gen_start":7034,"node":81,"role":"declaration","source":0,"src_end":3532,"src_start":3342},{"artifact":1,"gen_end":8283,"gen_start":7716,"node":82,"role":"declaration","source":0,"src_end":3670,"src_start":3534},{"artifact":1,"gen_end":8932,"gen_start":8283,"node":83,"role":"declaration","source":0,"src_end":3881,"src_start":3672},{"artifact":1,"gen_end":9524,"gen_start":8932,"node":84,"role":"declaration","source":0,"src_end":4023,"src_start":3883},{"artifact":1,"gen_end":10686,"gen_start":9524,"node":85,"role":"declaration","source":0,"src_end":4410,"src_start":4025},{"artifact":1,"gen_end":11177,"gen_start":10686,"node":86,"role":"declaration","source":0,"src_end":4598,"src_start":4412},{"artifact":1,"gen_end":11512,"gen_start":11177,"node":87,"role":"declaration","source":0,"src_end":4729,"src_start":4600},{"artifact":1,"gen_end":11816,"gen_start":11512,"node":88,"role":"declaration","source":0,"src_end":4976,"src_start":4731},{"artifact":1,"gen_end":12093,"gen_start":11816,"node":89,"role":"declaration","source":0,"src_end":5189,"src_start":4978},{"artifact":1,"gen_end":13177,"gen_start":12093,"node":90,"role":"declaration","source":0,"src_end":5464,"src_start":5191},{"artifact":1,"gen_end":13706,"gen_start":13177,"node":91,"role":"declaration","source":0,"src_end":5601,"src_start":5466},{"artifact":1,"gen_end":15155,"gen_start":13706,"node":92,"role":"declaration","source":0,"src_end":6046,"src_start":5603},{"artifact":1,"gen_end":16038,"gen_start":15155,"node":93,"role":"declaration","source":0,"src_end":6382,"src_start":6048},{"artifact":1,"gen_end":16569,"gen_start":16038,"node":94,"role":"declaration","source":0,"src_end":6653,"src_start":6384},{"artifact":1,"gen_end":16746,"gen_start":16569,"node":95,"role":"declaration","source":0,"src_end":6753,"src_start":6655},{"artifact":1,"gen_end":17024,"gen_start":16746,"node":96,"role":"declaration","source":0,"src_end":6973,"src_start":6755},{"artifact":1,"gen_end":17325,"gen_start":17024,"node":97,"role":"declaration","source":0,"src_end":7220,"src_start":6975},{"artifact":1,"gen_end":17599,"gen_start":17325,"node":98,"role":"declaration","source":0,"src_end":7432,"src_start":7222},{"artifact":1,"gen_end":19432,"gen_start":17599,"node":99,"role":"declaration","source":0,"src_end":7803,"src_start":7434},{"artifact":1,"gen_end":19963,"gen_start":19432,"node":100,"role":"declaration","source":0,"src_end":7938,"src_start":7805},{"artifact":1,"gen_end":20674,"gen_start":19963,"node":101,"role":"declaration","source":0,"src_end":8213,"src_start":7940},{"artifact":1,"gen_end":20965,"gen_start":20674,"node":102,"role":"declaration","source":0,"src_end":8441,"src_start":8215},{"artifact":1,"gen_end":21229,"gen_start":20965,"node":103,"role":"declaration","source":0,"src_end":8642,"src_start":8443},{"artifact":1,"gen_end":22305,"gen_start":21229,"node":104,"role":"declaration","source":0,"src_end":8925,"src_start":8644},{"artifact":1,"gen_end":22821,"gen_start":22305,"node":105,"role":"declaration","source":0,"src_end":9059,"src_start":8927},{"artifact":1,"gen_end":23062,"gen_start":22821,"node":106,"role":"declaration","source":0,"src_end":9139,"src_start":9061},{"artifact":1,"gen_end":23382,"gen_start":23062,"node":107,"role":"declaration","source":0,"src_end":9255,"src_start":9141},{"artifact":1,"gen_end":23640,"gen_start":23382,"node":108,"role":"declaration","source":0,"src_end":9459,"src_start":9257},{"artifact":1,"gen_end":23901,"gen_start":23640,"node":109,"role":"declaration","source":0,"src_end":9666,"src_start":9461},{"artifact":1,"gen_end":24150,"gen_start":23901,"node":110,"role":"declaration","source":0,"src_end":9753,"src_start":9668},{"artifact":1,"gen_end":24478,"gen_start":24150,"node":111,"role":"declaration","source":0,"src_end":9876,"src_start":9755},{"artifact":1,"gen_end":24751,"gen_start":24478,"node":112,"role":"declaration","source":0,"src_end":10088,"src_start":9878},{"artifact":1,"gen_end":26161,"gen_start":24751,"node":113,"role":"declaration","source":0,"src_end":10501,"src_start":10090},{"artifact":1,"gen_end":26595,"gen_start":26161,"node":114,"role":"declaration","source":0,"src_end":10659,"src_start":10503},{"artifact":1,"gen_end":26932,"gen_start":26595,"node":115,"role":"declaration","source":0,"src_end":10786,"src_start":10661},{"artifact":1,"gen_end":27188,"gen_start":26932,"node":116,"role":"declaration","source":0,"src_end":10985,"src_start":10788},{"artifact":1,"gen_end":27493,"gen_start":27188,"node":117,"role":"declaration","source":0,"src_end":11166,"src_start":10987},{"artifact":1,"gen_end":27846,"gen_start":27493,"node":118,"role":"declaration","source":0,"src_end":11313,"src_start":11168},{"artifact":1,"gen_end":28149,"gen_start":27846,"node":119,"role":"declaration","source":0,"src_end":11547,"src_start":11315},{"artifact":1,"gen_end":28618,"gen_start":28149,"node":120,"role":"declaration","source":0,"src_end":11857,"src_start":11549},{"artifact":1,"gen_end":29791,"gen_start":28618,"node":121,"role":"declaration","source":0,"src_end":12172,"src_start":11859},{"artifact":1,"gen_end":30207,"gen_start":29791,"node":122,"role":"declaration","source":0,"src_end":12307,"src_start":12174},{"artifact":1,"gen_end":30824,"gen_start":30207,"node":123,"role":"declaration","source":0,"src_end":12519,"src_start":12309},{"artifact":1,"gen_end":31255,"gen_start":30824,"node":124,"role":"declaration","source":0,"src_end":12664,"src_start":12521},{"artifact":1,"gen_end":31633,"gen_start":31255,"node":125,"role":"declaration","source":0,"src_end":12808,"src_start":12666},{"artifact":1,"gen_end":32058,"gen_start":31633,"node":126,"role":"declaration","source":0,"src_end":12906,"src_start":12810},{"artifact":1,"gen_end":32567,"gen_start":32058,"node":127,"role":"declaration","source":0,"src_end":13228,"src_start":12908},{"artifact":1,"gen_end":32582,"gen_start":32567,"node":64,"role":"declaration","source":0,"src_end":13264,"src_start":0}],"module":"Ledger","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-latex-module"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Ledger.lex.tex","sha256":"4eaf7867fbd19e7f03c139d4f5bfa753cc7022d2c1f2faf6b849abecff4e9815"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Ledger.lean"},{"id":1,"kind":"tex","path":"modules/Models/Ledger.tex"}],"mappings":[{"artifact":0,"gen_end":345,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":0,"gen_end":416,"gen_start":345,"node":1,"role":"declaration","source":0,"src_end":221,"src_start":142},{"artifact":0,"gen_end":490,"gen_start":416,"node":2,"role":"declaration","source":0,"src_end":338,"src_start":223},{"artifact":0,"gen_end":3533,"gen_start":490,"node":3,"role":"declaration","source":0,"src_end":542,"src_start":340},{"artifact":0,"gen_end":6579,"gen_start":3533,"node":4,"role":"declaration","source":0,"src_end":749,"src_start":544},{"artifact":0,"gen_end":6659,"gen_start":6579,"node":5,"role":"declaration","source":0,"src_end":837,"src_start":751},{"artifact":0,"gen_end":6742,"gen_start":6659,"node":6,"role":"declaration","source":0,"src_end":961,"src_start":839},{"artifact":0,"gen_end":9798,"gen_start":6742,"node":7,"role":"declaration","source":0,"src_end":1173,"src_start":963},{"artifact":0,"gen_end":9898,"gen_start":9798,"node":8,"role":"declaration","source":0,"src_end":1288,"src_start":1175},{"artifact":0,"gen_end":10001,"gen_start":9898,"node":9,"role":"declaration","source":0,"src_end":1429,"src_start":1290},{"artifact":0,"gen_end":13093,"gen_start":10001,"node":10,"role":"declaration","source":0,"src_end":1667,"src_start":1431},{"artifact":0,"gen_end":16188,"gen_start":13093,"node":11,"role":"declaration","source":0,"src_end":1908,"src_start":1669},{"artifact":0,"gen_end":17009,"gen_start":16188,"node":12,"role":"declaration","source":0,"src_end":2521,"src_start":1910},{"artifact":0,"gen_end":17140,"gen_start":17009,"node":13,"role":"declaration","source":0,"src_end":2709,"src_start":2523},{"artifact":0,"gen_end":17228,"gen_start":17140,"node":14,"role":"declaration","source":0,"src_end":2840,"src_start":2711},{"artifact":0,"gen_end":20330,"gen_start":17228,"node":15,"role":"declaration","source":0,"src_end":3111,"src_start":2842},{"artifact":0,"gen_end":23405,"gen_start":20330,"node":16,"role":"declaration","source":0,"src_end":3340,"src_start":3113},{"artifact":0,"gen_end":23603,"gen_start":23405,"node":17,"role":"declaration","source":0,"src_end":3532,"src_start":3342},{"artifact":0,"gen_end":23809,"gen_start":23603,"node":18,"role":"declaration","source":0,"src_end":3670,"src_start":3534},{"artifact":0,"gen_end":24020,"gen_start":23809,"node":19,"role":"declaration","source":0,"src_end":3881,"src_start":3672},{"artifact":0,"gen_end":24232,"gen_start":24020,"node":20,"role":"declaration","source":0,"src_end":4023,"src_start":3883},{"artifact":0,"gen_end":24552,"gen_start":24232,"node":21,"role":"declaration","source":0,"src_end":4410,"src_start":4025},{"artifact":0,"gen_end":24683,"gen_start":24552,"node":22,"role":"declaration","source":0,"src_end":4598,"src_start":4412},{"artifact":0,"gen_end":24771,"gen_start":24683,"node":23,"role":"declaration","source":0,"src_end":4729,"src_start":4600},{"artifact":0,"gen_end":27849,"gen_start":24771,"node":24,"role":"declaration","source":0,"src_end":4976,"src_start":4731},{"artifact":0,"gen_end":30908,"gen_start":27849,"node":25,"role":"declaration","source":0,"src_end":5189,"src_start":4978},{"artifact":0,"gen_end":31287,"gen_start":30908,"node":26,"role":"declaration","source":0,"src_end":5464,"src_start":5191},{"artifact":0,"gen_end":31493,"gen_start":31287,"node":27,"role":"declaration","source":0,"src_end":5601,"src_start":5466},{"artifact":0,"gen_end":31975,"gen_start":31493,"node":28,"role":"declaration","source":0,"src_end":6046,"src_start":5603},{"artifact":0,"gen_end":32302,"gen_start":31975,"node":29,"role":"declaration","source":0,"src_end":6382,"src_start":6048},{"artifact":0,"gen_end":32586,"gen_start":32302,"node":30,"role":"declaration","source":0,"src_end":6653,"src_start":6384},{"artifact":0,"gen_end":32656,"gen_start":32586,"node":31,"role":"declaration","source":0,"src_end":6753,"src_start":6655},{"artifact":0,"gen_end":35702,"gen_start":32656,"node":32,"role":"declaration","source":0,"src_end":6973,"src_start":6755},{"artifact":0,"gen_end":38778,"gen_start":35702,"node":33,"role":"declaration","source":0,"src_end":7220,"src_start":6975},{"artifact":0,"gen_end":41834,"gen_start":38778,"node":34,"role":"declaration","source":0,"src_end":7432,"src_start":7222},{"artifact":0,"gen_end":42532,"gen_start":41834,"node":35,"role":"declaration","source":0,"src_end":7803,"src_start":7434},{"artifact":0,"gen_end":42738,"gen_start":42532,"node":36,"role":"declaration","source":0,"src_end":7938,"src_start":7805},{"artifact":0,"gen_end":42898,"gen_start":42738,"node":37,"role":"declaration","source":0,"src_end":8213,"src_start":7940},{"artifact":0,"gen_end":45955,"gen_start":42898,"node":38,"role":"declaration","source":0,"src_end":8441,"src_start":8215},{"artifact":0,"gen_end":49000,"gen_start":45955,"node":39,"role":"declaration","source":0,"src_end":8642,"src_start":8443},{"artifact":0,"gen_end":49337,"gen_start":49000,"node":40,"role":"declaration","source":0,"src_end":8925,"src_start":8644},{"artifact":0,"gen_end":49541,"gen_start":49337,"node":41,"role":"declaration","source":0,"src_end":9059,"src_start":8927},{"artifact":0,"gen_end":49611,"gen_start":49541,"node":42,"role":"declaration","source":0,"src_end":9139,"src_start":9061},{"artifact":0,"gen_end":49684,"gen_start":49611,"node":43,"role":"declaration","source":0,"src_end":9255,"src_start":9141},{"artifact":0,"gen_end":52727,"gen_start":49684,"node":44,"role":"declaration","source":0,"src_end":9459,"src_start":9257},{"artifact":0,"gen_end":55773,"gen_start":52727,"node":45,"role":"declaration","source":0,"src_end":9666,"src_start":9461},{"artifact":0,"gen_end":55851,"gen_start":55773,"node":46,"role":"declaration","source":0,"src_end":9753,"src_start":9668},{"artifact":0,"gen_end":55932,"gen_start":55851,"node":47,"role":"declaration","source":0,"src_end":9876,"src_start":9755},{"artifact":0,"gen_end":58988,"gen_start":55932,"node":48,"role":"declaration","source":0,"src_end":10088,"src_start":9878},{"artifact":0,"gen_end":59482,"gen_start":58988,"node":49,"role":"declaration","source":0,"src_end":10501,"src_start":10090},{"artifact":0,"gen_end":59569,"gen_start":59482,"node":50,"role":"declaration","source":0,"src_end":10659,"src_start":10503},{"artifact":0,"gen_end":59659,"gen_start":59569,"node":51,"role":"declaration","source":0,"src_end":10786,"src_start":10661},{"artifact":0,"gen_end":62697,"gen_start":59659,"node":52,"role":"declaration","source":0,"src_end":10985,"src_start":10788},{"artifact":0,"gen_end":62856,"gen_start":62697,"node":53,"role":"declaration","source":0,"src_end":11166,"src_start":10987},{"artifact":0,"gen_end":62962,"gen_start":62856,"node":54,"role":"declaration","source":0,"src_end":11313,"src_start":11168},{"artifact":0,"gen_end":66038,"gen_start":62962,"node":55,"role":"declaration","source":0,"src_end":11547,"src_start":11315},{"artifact":0,"gen_end":66349,"gen_start":66038,"node":56,"role":"declaration","source":0,"src_end":11857,"src_start":11549},{"artifact":0,"gen_end":66519,"gen_start":66349,"node":57,"role":"declaration","source":0,"src_end":12172,"src_start":11859},{"artifact":0,"gen_end":66607,"gen_start":66519,"node":58,"role":"declaration","source":0,"src_end":12307,"src_start":12174},{"artifact":0,"gen_end":66792,"gen_start":66607,"node":59,"role":"declaration","source":0,"src_end":12519,"src_start":12309},{"artifact":0,"gen_end":66885,"gen_start":66792,"node":60,"role":"declaration","source":0,"src_end":12664,"src_start":12521},{"artifact":0,"gen_end":66944,"gen_start":66885,"node":61,"role":"declaration","source":0,"src_end":12808,"src_start":12666},{"artifact":0,"gen_end":67040,"gen_start":66944,"node":62,"role":"declaration","source":0,"src_end":12906,"src_start":12810},{"artifact":0,"gen_end":67223,"gen_start":67040,"node":63,"role":"declaration","source":0,"src_end":13228,"src_start":12908},{"artifact":0,"gen_end":67242,"gen_start":67223,"node":0,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":64,"role":"declaration","source":0,"src_end":13264,"src_start":0},{"artifact":1,"gen_end":376,"gen_start":134,"node":65,"role":"declaration","source":0,"src_end":221,"src_start":142},{"artifact":1,"gen_end":697,"gen_start":376,"node":66,"role":"declaration","source":0,"src_end":338,"src_start":223},{"artifact":1,"gen_end":955,"gen_start":697,"node":67,"role":"declaration","source":0,"src_end":542,"src_start":340},{"artifact":1,"gen_end":1216,"gen_start":955,"node":68,"role":"declaration","source":0,"src_end":749,"src_start":544},{"artifact":1,"gen_end":1466,"gen_start":1216,"node":69,"role":"declaration","source":0,"src_end":837,"src_start":751},{"artifact":1,"gen_end":1795,"gen_start":1466,"node":70,"role":"declaration","source":0,"src_end":961,"src_start":839},{"artifact":1,"gen_end":2068,"gen_start":1795,"node":71,"role":"declaration","source":0,"src_end":1173,"src_start":963},{"artifact":1,"gen_end":2337,"gen_start":2068,"node":72,"role":"declaration","source":0,"src_end":1288,"src_start":1175},{"artifact":1,"gen_end":2685,"gen_start":2337,"node":73,"role":"declaration","source":0,"src_end":1429,"src_start":1290},{"artifact":1,"gen_end":2994,"gen_start":2685,"node":74,"role":"declaration","source":0,"src_end":1667,"src_start":1431},{"artifact":1,"gen_end":3306,"gen_start":2994,"node":75,"role":"declaration","source":0,"src_end":1908,"src_start":1669},{"artifact":1,"gen_end":5595,"gen_start":3306,"node":76,"role":"declaration","source":0,"src_end":2521,"src_start":1910},{"artifact":1,"gen_end":6086,"gen_start":5595,"node":77,"role":"declaration","source":0,"src_end":2709,"src_start":2523},{"artifact":1,"gen_end":6421,"gen_start":6086,"node":78,"role":"declaration","source":0,"src_end":2840,"src_start":2711},{"artifact":1,"gen_end":6741,"gen_start":6421,"node":79,"role":"declaration","source":0,"src_end":3111,"src_start":2842},{"artifact":1,"gen_end":7034,"gen_start":6741,"node":80,"role":"declaration","source":0,"src_end":3340,"src_start":3113},{"artifact":1,"gen_end":7716,"gen_start":7034,"node":81,"role":"declaration","source":0,"src_end":3532,"src_start":3342},{"artifact":1,"gen_end":8283,"gen_start":7716,"node":82,"role":"declaration","source":0,"src_end":3670,"src_start":3534},{"artifact":1,"gen_end":8932,"gen_start":8283,"node":83,"role":"declaration","source":0,"src_end":3881,"src_start":3672},{"artifact":1,"gen_end":9524,"gen_start":8932,"node":84,"role":"declaration","source":0,"src_end":4023,"src_start":3883},{"artifact":1,"gen_end":10686,"gen_start":9524,"node":85,"role":"declaration","source":0,"src_end":4410,"src_start":4025},{"artifact":1,"gen_end":11177,"gen_start":10686,"node":86,"role":"declaration","source":0,"src_end":4598,"src_start":4412},{"artifact":1,"gen_end":11512,"gen_start":11177,"node":87,"role":"declaration","source":0,"src_end":4729,"src_start":4600},{"artifact":1,"gen_end":11816,"gen_start":11512,"node":88,"role":"declaration","source":0,"src_end":4976,"src_start":4731},{"artifact":1,"gen_end":12093,"gen_start":11816,"node":89,"role":"declaration","source":0,"src_end":5189,"src_start":4978},{"artifact":1,"gen_end":13177,"gen_start":12093,"node":90,"role":"declaration","source":0,"src_end":5464,"src_start":5191},{"artifact":1,"gen_end":13706,"gen_start":13177,"node":91,"role":"declaration","source":0,"src_end":5601,"src_start":5466},{"artifact":1,"gen_end":15155,"gen_start":13706,"node":92,"role":"declaration","source":0,"src_end":6046,"src_start":5603},{"artifact":1,"gen_end":16038,"gen_start":15155,"node":93,"role":"declaration","source":0,"src_end":6382,"src_start":6048},{"artifact":1,"gen_end":16569,"gen_start":16038,"node":94,"role":"declaration","source":0,"src_end":6653,"src_start":6384},{"artifact":1,"gen_end":16746,"gen_start":16569,"node":95,"role":"declaration","source":0,"src_end":6753,"src_start":6655},{"artifact":1,"gen_end":17024,"gen_start":16746,"node":96,"role":"declaration","source":0,"src_end":6973,"src_start":6755},{"artifact":1,"gen_end":17325,"gen_start":17024,"node":97,"role":"declaration","source":0,"src_end":7220,"src_start":6975},{"artifact":1,"gen_end":17599,"gen_start":17325,"node":98,"role":"declaration","source":0,"src_end":7432,"src_start":7222},{"artifact":1,"gen_end":19432,"gen_start":17599,"node":99,"role":"declaration","source":0,"src_end":7803,"src_start":7434},{"artifact":1,"gen_end":19963,"gen_start":19432,"node":100,"role":"declaration","source":0,"src_end":7938,"src_start":7805},{"artifact":1,"gen_end":20674,"gen_start":19963,"node":101,"role":"declaration","source":0,"src_end":8213,"src_start":7940},{"artifact":1,"gen_end":20965,"gen_start":20674,"node":102,"role":"declaration","source":0,"src_end":8441,"src_start":8215},{"artifact":1,"gen_end":21229,"gen_start":20965,"node":103,"role":"declaration","source":0,"src_end":8642,"src_start":8443},{"artifact":1,"gen_end":22305,"gen_start":21229,"node":104,"role":"declaration","source":0,"src_end":8925,"src_start":8644},{"artifact":1,"gen_end":22821,"gen_start":22305,"node":105,"role":"declaration","source":0,"src_end":9059,"src_start":8927},{"artifact":1,"gen_end":23062,"gen_start":22821,"node":106,"role":"declaration","source":0,"src_end":9139,"src_start":9061},{"artifact":1,"gen_end":23382,"gen_start":23062,"node":107,"role":"declaration","source":0,"src_end":9255,"src_start":9141},{"artifact":1,"gen_end":23640,"gen_start":23382,"node":108,"role":"declaration","source":0,"src_end":9459,"src_start":9257},{"artifact":1,"gen_end":23901,"gen_start":23640,"node":109,"role":"declaration","source":0,"src_end":9666,"src_start":9461},{"artifact":1,"gen_end":24150,"gen_start":23901,"node":110,"role":"declaration","source":0,"src_end":9753,"src_start":9668},{"artifact":1,"gen_end":24478,"gen_start":24150,"node":111,"role":"declaration","source":0,"src_end":9876,"src_start":9755},{"artifact":1,"gen_end":24751,"gen_start":24478,"node":112,"role":"declaration","source":0,"src_end":10088,"src_start":9878},{"artifact":1,"gen_end":26161,"gen_start":24751,"node":113,"role":"declaration","source":0,"src_end":10501,"src_start":10090},{"artifact":1,"gen_end":26595,"gen_start":26161,"node":114,"role":"declaration","source":0,"src_end":10659,"src_start":10503},{"artifact":1,"gen_end":26932,"gen_start":26595,"node":115,"role":"declaration","source":0,"src_end":10786,"src_start":10661},{"artifact":1,"gen_end":27188,"gen_start":26932,"node":116,"role":"declaration","source":0,"src_end":10985,"src_start":10788},{"artifact":1,"gen_end":27493,"gen_start":27188,"node":117,"role":"declaration","source":0,"src_end":11166,"src_start":10987},{"artifact":1,"gen_end":27846,"gen_start":27493,"node":118,"role":"declaration","source":0,"src_end":11313,"src_start":11168},{"artifact":1,"gen_end":28149,"gen_start":27846,"node":119,"role":"declaration","source":0,"src_end":11547,"src_start":11315},{"artifact":1,"gen_end":28618,"gen_start":28149,"node":120,"role":"declaration","source":0,"src_end":11857,"src_start":11549},{"artifact":1,"gen_end":29791,"gen_start":28618,"node":121,"role":"declaration","source":0,"src_end":12172,"src_start":11859},{"artifact":1,"gen_end":30207,"gen_start":29791,"node":122,"role":"declaration","source":0,"src_end":12307,"src_start":12174},{"artifact":1,"gen_end":30824,"gen_start":30207,"node":123,"role":"declaration","source":0,"src_end":12519,"src_start":12309},{"artifact":1,"gen_end":31255,"gen_start":30824,"node":124,"role":"declaration","source":0,"src_end":12664,"src_start":12521},{"artifact":1,"gen_end":31633,"gen_start":31255,"node":125,"role":"declaration","source":0,"src_end":12808,"src_start":12666},{"artifact":1,"gen_end":32058,"gen_start":31633,"node":126,"role":"declaration","source":0,"src_end":12906,"src_start":12810},{"artifact":1,"gen_end":32567,"gen_start":32058,"node":127,"role":"declaration","source":0,"src_end":13228,"src_start":12908},{"artifact":1,"gen_end":32582,"gen_start":32567,"node":64,"role":"declaration","source":0,"src_end":13264,"src_start":0}],"module":"Ledger","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-latex-module"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Ledger.lex.tex","sha256":"4eaf7867fbd19e7f03c139d4f5bfa753cc7022d2c1f2faf6b849abecff4e9815"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Main.map.json b/examples/models/expected/build/maps/Models/Main.map.json index ab12d6e70..17fe68872 100644 --- a/examples/models/expected/build/maps/Models/Main.map.json +++ b/examples/models/expected/build/maps/Models/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Main.lean"},{"id":1,"kind":"tex","path":"modules/Models/Main.tex"}],"mappings":[{"artifact":0,"gen_end":434,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":0,"gen_end":541,"gen_start":434,"node":1,"role":"declaration","source":0,"src_end":541,"src_start":295},{"artifact":0,"gen_end":952,"gen_start":541,"node":2,"role":"declaration","source":0,"src_end":855,"src_start":543},{"artifact":0,"gen_end":1359,"gen_start":952,"node":3,"role":"declaration","source":0,"src_end":1179,"src_start":857},{"artifact":0,"gen_end":1793,"gen_start":1359,"node":4,"role":"declaration","source":0,"src_end":1493,"src_start":1181},{"artifact":0,"gen_end":2434,"gen_start":1793,"node":5,"role":"declaration","source":0,"src_end":1828,"src_start":1495},{"artifact":0,"gen_end":2522,"gen_start":2434,"node":6,"role":"declaration","source":0,"src_end":1976,"src_start":1830},{"artifact":0,"gen_end":2770,"gen_start":2522,"node":7,"role":"declaration","source":0,"src_end":2307,"src_start":1978},{"artifact":0,"gen_end":2888,"gen_start":2770,"node":8,"role":"declaration","source":0,"src_end":2459,"src_start":2309},{"artifact":0,"gen_end":3012,"gen_start":2888,"node":9,"role":"declaration","source":0,"src_end":2619,"src_start":2461},{"artifact":0,"gen_end":3670,"gen_start":3012,"node":10,"role":"declaration","source":0,"src_end":2935,"src_start":2621},{"artifact":0,"gen_end":4501,"gen_start":3670,"node":11,"role":"declaration","source":0,"src_end":3269,"src_start":2937},{"artifact":0,"gen_end":4962,"gen_start":4501,"node":12,"role":"declaration","source":0,"src_end":3548,"src_start":3271},{"artifact":0,"gen_end":5431,"gen_start":4962,"node":13,"role":"declaration","source":0,"src_end":3754,"src_start":3550},{"artifact":0,"gen_end":6014,"gen_start":5431,"node":14,"role":"declaration","source":0,"src_end":4079,"src_start":3756},{"artifact":0,"gen_end":6435,"gen_start":6014,"node":15,"role":"declaration","source":0,"src_end":4298,"src_start":4081},{"artifact":0,"gen_end":6864,"gen_start":6435,"node":16,"role":"declaration","source":0,"src_end":4525,"src_start":4300},{"artifact":0,"gen_end":7617,"gen_start":6864,"node":17,"role":"declaration","source":0,"src_end":4780,"src_start":4527},{"artifact":0,"gen_end":8276,"gen_start":7617,"node":18,"role":"declaration","source":0,"src_end":5035,"src_start":4782},{"artifact":0,"gen_end":9003,"gen_start":8276,"node":19,"role":"declaration","source":0,"src_end":5286,"src_start":5037},{"artifact":0,"gen_end":9784,"gen_start":9003,"node":20,"role":"declaration","source":0,"src_end":5562,"src_start":5288},{"artifact":0,"gen_end":10441,"gen_start":9784,"node":21,"role":"declaration","source":0,"src_end":5830,"src_start":5564},{"artifact":0,"gen_end":11102,"gen_start":10441,"node":22,"role":"declaration","source":0,"src_end":6102,"src_start":5832},{"artifact":0,"gen_end":11522,"gen_start":11102,"node":23,"role":"declaration","source":0,"src_end":6332,"src_start":6104},{"artifact":0,"gen_end":11747,"gen_start":11522,"node":24,"role":"declaration","source":0,"src_end":6601,"src_start":6334},{"artifact":0,"gen_end":11956,"gen_start":11747,"node":25,"role":"declaration","source":0,"src_end":6857,"src_start":6603},{"artifact":0,"gen_end":12276,"gen_start":11956,"node":26,"role":"declaration","source":0,"src_end":7211,"src_start":6859},{"artifact":0,"gen_end":12695,"gen_start":12276,"node":27,"role":"declaration","source":0,"src_end":7650,"src_start":7213},{"artifact":0,"gen_end":13036,"gen_start":12695,"node":28,"role":"declaration","source":0,"src_end":8018,"src_start":7652},{"artifact":0,"gen_end":13416,"gen_start":13036,"node":29,"role":"declaration","source":0,"src_end":8424,"src_start":8020},{"artifact":0,"gen_end":13843,"gen_start":13416,"node":30,"role":"declaration","source":0,"src_end":8886,"src_start":8426},{"artifact":0,"gen_end":14237,"gen_start":13843,"node":31,"role":"declaration","source":0,"src_end":9315,"src_start":8888},{"artifact":0,"gen_end":14323,"gen_start":14237,"node":32,"role":"declaration","source":0,"src_end":9437,"src_start":9317},{"artifact":0,"gen_end":14415,"gen_start":14323,"node":33,"role":"declaration","source":0,"src_end":9565,"src_start":9439},{"artifact":0,"gen_end":14513,"gen_start":14415,"node":34,"role":"declaration","source":0,"src_end":9699,"src_start":9567},{"artifact":0,"gen_end":14605,"gen_start":14513,"node":35,"role":"declaration","source":0,"src_end":9827,"src_start":9701},{"artifact":0,"gen_end":14696,"gen_start":14605,"node":36,"role":"declaration","source":0,"src_end":9954,"src_start":9829},{"artifact":0,"gen_end":14793,"gen_start":14696,"node":37,"role":"declaration","source":0,"src_end":10087,"src_start":9956},{"artifact":0,"gen_end":14877,"gen_start":14793,"node":38,"role":"declaration","source":0,"src_end":10209,"src_start":10089},{"artifact":0,"gen_end":14973,"gen_start":14877,"node":39,"role":"declaration","source":0,"src_end":10343,"src_start":10211},{"artifact":0,"gen_end":15077,"gen_start":14973,"node":40,"role":"declaration","source":0,"src_end":10485,"src_start":10345},{"artifact":0,"gen_end":15160,"gen_start":15077,"node":41,"role":"declaration","source":0,"src_end":10604,"src_start":10487},{"artifact":0,"gen_end":15253,"gen_start":15160,"node":42,"role":"declaration","source":0,"src_end":10733,"src_start":10606},{"artifact":0,"gen_end":15341,"gen_start":15253,"node":43,"role":"declaration","source":0,"src_end":10857,"src_start":10735},{"artifact":0,"gen_end":15423,"gen_start":15341,"node":44,"role":"declaration","source":0,"src_end":10977,"src_start":10859},{"artifact":0,"gen_end":15504,"gen_start":15423,"node":45,"role":"declaration","source":0,"src_end":11096,"src_start":10979},{"artifact":0,"gen_end":15612,"gen_start":15504,"node":46,"role":"declaration","source":0,"src_end":11242,"src_start":11098},{"artifact":0,"gen_end":15706,"gen_start":15612,"node":47,"role":"declaration","source":0,"src_end":11372,"src_start":11244},{"artifact":0,"gen_end":15805,"gen_start":15706,"node":48,"role":"declaration","source":0,"src_end":11507,"src_start":11374},{"artifact":0,"gen_end":15898,"gen_start":15805,"node":49,"role":"declaration","source":0,"src_end":11636,"src_start":11509},{"artifact":0,"gen_end":16006,"gen_start":15898,"node":50,"role":"declaration","source":0,"src_end":11780,"src_start":11638},{"artifact":0,"gen_end":16111,"gen_start":16006,"node":51,"role":"declaration","source":0,"src_end":11921,"src_start":11782},{"artifact":0,"gen_end":16211,"gen_start":16111,"node":52,"role":"declaration","source":0,"src_end":12057,"src_start":11923},{"artifact":0,"gen_end":16311,"gen_start":16211,"node":53,"role":"declaration","source":0,"src_end":12193,"src_start":12059},{"artifact":0,"gen_end":16416,"gen_start":16311,"node":54,"role":"declaration","source":0,"src_end":12334,"src_start":12195},{"artifact":0,"gen_end":16510,"gen_start":16416,"node":55,"role":"declaration","source":0,"src_end":12464,"src_start":12336},{"artifact":0,"gen_end":16619,"gen_start":16510,"node":56,"role":"declaration","source":0,"src_end":12609,"src_start":12466},{"artifact":0,"gen_end":16721,"gen_start":16619,"node":57,"role":"declaration","source":0,"src_end":12747,"src_start":12611},{"artifact":0,"gen_end":16823,"gen_start":16721,"node":58,"role":"declaration","source":0,"src_end":12885,"src_start":12749},{"artifact":0,"gen_end":16932,"gen_start":16823,"node":59,"role":"declaration","source":0,"src_end":13030,"src_start":12887},{"artifact":0,"gen_end":17049,"gen_start":16932,"node":60,"role":"declaration","source":0,"src_end":13183,"src_start":13032},{"artifact":0,"gen_end":17155,"gen_start":17049,"node":61,"role":"declaration","source":0,"src_end":13325,"src_start":13185},{"artifact":0,"gen_end":17275,"gen_start":17155,"node":62,"role":"declaration","source":0,"src_end":13481,"src_start":13327},{"artifact":0,"gen_end":17456,"gen_start":17275,"node":63,"role":"declaration","source":0,"src_end":13712,"src_start":13483},{"artifact":0,"gen_end":17651,"gen_start":17456,"node":64,"role":"declaration","source":0,"src_end":13959,"src_start":13714},{"artifact":0,"gen_end":17668,"gen_start":17651,"node":0,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":65,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":1,"gen_end":620,"gen_start":134,"node":66,"role":"declaration","source":0,"src_end":541,"src_start":295},{"artifact":1,"gen_end":1171,"gen_start":620,"node":67,"role":"declaration","source":0,"src_end":855,"src_start":543},{"artifact":1,"gen_end":1732,"gen_start":1171,"node":68,"role":"declaration","source":0,"src_end":1179,"src_start":857},{"artifact":1,"gen_end":2289,"gen_start":1732,"node":69,"role":"declaration","source":0,"src_end":1493,"src_start":1181},{"artifact":1,"gen_end":2888,"gen_start":2289,"node":70,"role":"declaration","source":0,"src_end":1828,"src_start":1495},{"artifact":1,"gen_end":3094,"gen_start":2888,"node":71,"role":"declaration","source":0,"src_end":1976,"src_start":1830},{"artifact":1,"gen_end":3594,"gen_start":3094,"node":72,"role":"declaration","source":0,"src_end":2307,"src_start":1978},{"artifact":1,"gen_end":3820,"gen_start":3594,"node":73,"role":"declaration","source":0,"src_end":2459,"src_start":2309},{"artifact":1,"gen_end":4052,"gen_start":3820,"node":74,"role":"declaration","source":0,"src_end":2619,"src_start":2461},{"artifact":1,"gen_end":4621,"gen_start":4052,"node":75,"role":"declaration","source":0,"src_end":2935,"src_start":2621},{"artifact":1,"gen_end":5208,"gen_start":4621,"node":76,"role":"declaration","source":0,"src_end":3269,"src_start":2937},{"artifact":1,"gen_end":5728,"gen_start":5208,"node":77,"role":"declaration","source":0,"src_end":3548,"src_start":3271},{"artifact":1,"gen_end":6135,"gen_start":5728,"node":78,"role":"declaration","source":0,"src_end":3754,"src_start":3550},{"artifact":1,"gen_end":6715,"gen_start":6135,"node":79,"role":"declaration","source":0,"src_end":4079,"src_start":3756},{"artifact":1,"gen_end":7144,"gen_start":6715,"node":80,"role":"declaration","source":0,"src_end":4298,"src_start":4081},{"artifact":1,"gen_end":7581,"gen_start":7144,"node":81,"role":"declaration","source":0,"src_end":4525,"src_start":4300},{"artifact":1,"gen_end":8070,"gen_start":7581,"node":82,"role":"declaration","source":0,"src_end":4780,"src_start":4527},{"artifact":1,"gen_end":8566,"gen_start":8070,"node":83,"role":"declaration","source":0,"src_end":5035,"src_start":4782},{"artifact":1,"gen_end":9044,"gen_start":8566,"node":84,"role":"declaration","source":0,"src_end":5286,"src_start":5037},{"artifact":1,"gen_end":9549,"gen_start":9044,"node":85,"role":"declaration","source":0,"src_end":5562,"src_start":5288},{"artifact":1,"gen_end":10046,"gen_start":9549,"node":86,"role":"declaration","source":0,"src_end":5830,"src_start":5564},{"artifact":1,"gen_end":10547,"gen_start":10046,"node":87,"role":"declaration","source":0,"src_end":6102,"src_start":5832},{"artifact":1,"gen_end":10980,"gen_start":10547,"node":88,"role":"declaration","source":0,"src_end":6332,"src_start":6104},{"artifact":1,"gen_end":11453,"gen_start":10980,"node":89,"role":"declaration","source":0,"src_end":6601,"src_start":6334},{"artifact":1,"gen_end":11910,"gen_start":11453,"node":90,"role":"declaration","source":0,"src_end":6857,"src_start":6603},{"artifact":1,"gen_end":12479,"gen_start":11910,"node":91,"role":"declaration","source":0,"src_end":7211,"src_start":6859},{"artifact":1,"gen_end":13146,"gen_start":12479,"node":92,"role":"declaration","source":0,"src_end":7650,"src_start":7213},{"artifact":1,"gen_end":13735,"gen_start":13146,"node":93,"role":"declaration","source":0,"src_end":8018,"src_start":7652},{"artifact":1,"gen_end":14364,"gen_start":13735,"node":94,"role":"declaration","source":0,"src_end":8424,"src_start":8020},{"artifact":1,"gen_end":15040,"gen_start":14364,"node":95,"role":"declaration","source":0,"src_end":8886,"src_start":8426},{"artifact":1,"gen_end":15683,"gen_start":15040,"node":96,"role":"declaration","source":0,"src_end":9315,"src_start":8888},{"artifact":1,"gen_end":15876,"gen_start":15683,"node":97,"role":"declaration","source":0,"src_end":9437,"src_start":9317},{"artifact":1,"gen_end":16076,"gen_start":15876,"node":98,"role":"declaration","source":0,"src_end":9565,"src_start":9439},{"artifact":1,"gen_end":16282,"gen_start":16076,"node":99,"role":"declaration","source":0,"src_end":9699,"src_start":9567},{"artifact":1,"gen_end":16482,"gen_start":16282,"node":100,"role":"declaration","source":0,"src_end":9827,"src_start":9701},{"artifact":1,"gen_end":16681,"gen_start":16482,"node":101,"role":"declaration","source":0,"src_end":9954,"src_start":9829},{"artifact":1,"gen_end":16887,"gen_start":16681,"node":102,"role":"declaration","source":0,"src_end":10087,"src_start":9956},{"artifact":1,"gen_end":17078,"gen_start":16887,"node":103,"role":"declaration","source":0,"src_end":10209,"src_start":10089},{"artifact":1,"gen_end":17282,"gen_start":17078,"node":104,"role":"declaration","source":0,"src_end":10343,"src_start":10211},{"artifact":1,"gen_end":17494,"gen_start":17282,"node":105,"role":"declaration","source":0,"src_end":10485,"src_start":10345},{"artifact":1,"gen_end":17684,"gen_start":17494,"node":106,"role":"declaration","source":0,"src_end":10604,"src_start":10487},{"artifact":1,"gen_end":17885,"gen_start":17684,"node":107,"role":"declaration","source":0,"src_end":10733,"src_start":10606},{"artifact":1,"gen_end":18081,"gen_start":17885,"node":108,"role":"declaration","source":0,"src_end":10857,"src_start":10735},{"artifact":1,"gen_end":18270,"gen_start":18081,"node":109,"role":"declaration","source":0,"src_end":10977,"src_start":10859},{"artifact":1,"gen_end":18458,"gen_start":18270,"node":110,"role":"declaration","source":0,"src_end":11096,"src_start":10979},{"artifact":1,"gen_end":18675,"gen_start":18458,"node":111,"role":"declaration","source":0,"src_end":11242,"src_start":11098},{"artifact":1,"gen_end":18876,"gen_start":18675,"node":112,"role":"declaration","source":0,"src_end":11372,"src_start":11244},{"artifact":1,"gen_end":19083,"gen_start":18876,"node":113,"role":"declaration","source":0,"src_end":11507,"src_start":11374},{"artifact":1,"gen_end":19284,"gen_start":19083,"node":114,"role":"declaration","source":0,"src_end":11636,"src_start":11509},{"artifact":1,"gen_end":19500,"gen_start":19284,"node":115,"role":"declaration","source":0,"src_end":11780,"src_start":11638},{"artifact":1,"gen_end":19714,"gen_start":19500,"node":116,"role":"declaration","source":0,"src_end":11921,"src_start":11782},{"artifact":1,"gen_end":19922,"gen_start":19714,"node":117,"role":"declaration","source":0,"src_end":12057,"src_start":11923},{"artifact":1,"gen_end":20130,"gen_start":19922,"node":118,"role":"declaration","source":0,"src_end":12193,"src_start":12059},{"artifact":1,"gen_end":20343,"gen_start":20130,"node":119,"role":"declaration","source":0,"src_end":12334,"src_start":12195},{"artifact":1,"gen_end":20544,"gen_start":20343,"node":120,"role":"declaration","source":0,"src_end":12464,"src_start":12336},{"artifact":1,"gen_end":20762,"gen_start":20544,"node":121,"role":"declaration","source":0,"src_end":12609,"src_start":12466},{"artifact":1,"gen_end":20972,"gen_start":20762,"node":122,"role":"declaration","source":0,"src_end":12747,"src_start":12611},{"artifact":1,"gen_end":21182,"gen_start":20972,"node":123,"role":"declaration","source":0,"src_end":12885,"src_start":12749},{"artifact":1,"gen_end":21400,"gen_start":21182,"node":124,"role":"declaration","source":0,"src_end":13030,"src_start":12887},{"artifact":1,"gen_end":21626,"gen_start":21400,"node":125,"role":"declaration","source":0,"src_end":13183,"src_start":13032},{"artifact":1,"gen_end":21840,"gen_start":21626,"node":126,"role":"declaration","source":0,"src_end":13325,"src_start":13185},{"artifact":1,"gen_end":22069,"gen_start":21840,"node":127,"role":"declaration","source":0,"src_end":13481,"src_start":13327},{"artifact":1,"gen_end":22357,"gen_start":22069,"node":128,"role":"declaration","source":0,"src_end":13712,"src_start":13483},{"artifact":1,"gen_end":22660,"gen_start":22357,"node":129,"role":"declaration","source":0,"src_end":13959,"src_start":13714},{"artifact":1,"gen_end":22675,"gen_start":22660,"node":65,"role":"declaration","source":0,"src_end":13995,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-latex-module"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"09fef2732bb2b95f41909df0570942389cddbf5bcefe01e667b6ec7400caad75"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Main.lean"},{"id":1,"kind":"tex","path":"modules/Models/Main.tex"}],"mappings":[{"artifact":0,"gen_end":434,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":0,"gen_end":541,"gen_start":434,"node":1,"role":"declaration","source":0,"src_end":541,"src_start":295},{"artifact":0,"gen_end":952,"gen_start":541,"node":2,"role":"declaration","source":0,"src_end":855,"src_start":543},{"artifact":0,"gen_end":1359,"gen_start":952,"node":3,"role":"declaration","source":0,"src_end":1179,"src_start":857},{"artifact":0,"gen_end":1793,"gen_start":1359,"node":4,"role":"declaration","source":0,"src_end":1493,"src_start":1181},{"artifact":0,"gen_end":2434,"gen_start":1793,"node":5,"role":"declaration","source":0,"src_end":1828,"src_start":1495},{"artifact":0,"gen_end":2522,"gen_start":2434,"node":6,"role":"declaration","source":0,"src_end":1976,"src_start":1830},{"artifact":0,"gen_end":2770,"gen_start":2522,"node":7,"role":"declaration","source":0,"src_end":2307,"src_start":1978},{"artifact":0,"gen_end":2888,"gen_start":2770,"node":8,"role":"declaration","source":0,"src_end":2459,"src_start":2309},{"artifact":0,"gen_end":3012,"gen_start":2888,"node":9,"role":"declaration","source":0,"src_end":2619,"src_start":2461},{"artifact":0,"gen_end":3670,"gen_start":3012,"node":10,"role":"declaration","source":0,"src_end":2935,"src_start":2621},{"artifact":0,"gen_end":4501,"gen_start":3670,"node":11,"role":"declaration","source":0,"src_end":3269,"src_start":2937},{"artifact":0,"gen_end":4962,"gen_start":4501,"node":12,"role":"declaration","source":0,"src_end":3548,"src_start":3271},{"artifact":0,"gen_end":5431,"gen_start":4962,"node":13,"role":"declaration","source":0,"src_end":3754,"src_start":3550},{"artifact":0,"gen_end":6014,"gen_start":5431,"node":14,"role":"declaration","source":0,"src_end":4079,"src_start":3756},{"artifact":0,"gen_end":6435,"gen_start":6014,"node":15,"role":"declaration","source":0,"src_end":4298,"src_start":4081},{"artifact":0,"gen_end":6864,"gen_start":6435,"node":16,"role":"declaration","source":0,"src_end":4525,"src_start":4300},{"artifact":0,"gen_end":7617,"gen_start":6864,"node":17,"role":"declaration","source":0,"src_end":4780,"src_start":4527},{"artifact":0,"gen_end":8276,"gen_start":7617,"node":18,"role":"declaration","source":0,"src_end":5035,"src_start":4782},{"artifact":0,"gen_end":9003,"gen_start":8276,"node":19,"role":"declaration","source":0,"src_end":5286,"src_start":5037},{"artifact":0,"gen_end":9784,"gen_start":9003,"node":20,"role":"declaration","source":0,"src_end":5562,"src_start":5288},{"artifact":0,"gen_end":10441,"gen_start":9784,"node":21,"role":"declaration","source":0,"src_end":5830,"src_start":5564},{"artifact":0,"gen_end":11102,"gen_start":10441,"node":22,"role":"declaration","source":0,"src_end":6102,"src_start":5832},{"artifact":0,"gen_end":11522,"gen_start":11102,"node":23,"role":"declaration","source":0,"src_end":6332,"src_start":6104},{"artifact":0,"gen_end":11747,"gen_start":11522,"node":24,"role":"declaration","source":0,"src_end":6601,"src_start":6334},{"artifact":0,"gen_end":11956,"gen_start":11747,"node":25,"role":"declaration","source":0,"src_end":6857,"src_start":6603},{"artifact":0,"gen_end":12276,"gen_start":11956,"node":26,"role":"declaration","source":0,"src_end":7211,"src_start":6859},{"artifact":0,"gen_end":12695,"gen_start":12276,"node":27,"role":"declaration","source":0,"src_end":7650,"src_start":7213},{"artifact":0,"gen_end":13036,"gen_start":12695,"node":28,"role":"declaration","source":0,"src_end":8018,"src_start":7652},{"artifact":0,"gen_end":13416,"gen_start":13036,"node":29,"role":"declaration","source":0,"src_end":8424,"src_start":8020},{"artifact":0,"gen_end":13843,"gen_start":13416,"node":30,"role":"declaration","source":0,"src_end":8886,"src_start":8426},{"artifact":0,"gen_end":14237,"gen_start":13843,"node":31,"role":"declaration","source":0,"src_end":9315,"src_start":8888},{"artifact":0,"gen_end":14323,"gen_start":14237,"node":32,"role":"declaration","source":0,"src_end":9437,"src_start":9317},{"artifact":0,"gen_end":14415,"gen_start":14323,"node":33,"role":"declaration","source":0,"src_end":9565,"src_start":9439},{"artifact":0,"gen_end":14513,"gen_start":14415,"node":34,"role":"declaration","source":0,"src_end":9699,"src_start":9567},{"artifact":0,"gen_end":14605,"gen_start":14513,"node":35,"role":"declaration","source":0,"src_end":9827,"src_start":9701},{"artifact":0,"gen_end":14696,"gen_start":14605,"node":36,"role":"declaration","source":0,"src_end":9954,"src_start":9829},{"artifact":0,"gen_end":14793,"gen_start":14696,"node":37,"role":"declaration","source":0,"src_end":10087,"src_start":9956},{"artifact":0,"gen_end":14877,"gen_start":14793,"node":38,"role":"declaration","source":0,"src_end":10209,"src_start":10089},{"artifact":0,"gen_end":14973,"gen_start":14877,"node":39,"role":"declaration","source":0,"src_end":10343,"src_start":10211},{"artifact":0,"gen_end":15077,"gen_start":14973,"node":40,"role":"declaration","source":0,"src_end":10485,"src_start":10345},{"artifact":0,"gen_end":15160,"gen_start":15077,"node":41,"role":"declaration","source":0,"src_end":10604,"src_start":10487},{"artifact":0,"gen_end":15253,"gen_start":15160,"node":42,"role":"declaration","source":0,"src_end":10733,"src_start":10606},{"artifact":0,"gen_end":15341,"gen_start":15253,"node":43,"role":"declaration","source":0,"src_end":10857,"src_start":10735},{"artifact":0,"gen_end":15423,"gen_start":15341,"node":44,"role":"declaration","source":0,"src_end":10977,"src_start":10859},{"artifact":0,"gen_end":15504,"gen_start":15423,"node":45,"role":"declaration","source":0,"src_end":11096,"src_start":10979},{"artifact":0,"gen_end":15612,"gen_start":15504,"node":46,"role":"declaration","source":0,"src_end":11242,"src_start":11098},{"artifact":0,"gen_end":15706,"gen_start":15612,"node":47,"role":"declaration","source":0,"src_end":11372,"src_start":11244},{"artifact":0,"gen_end":15805,"gen_start":15706,"node":48,"role":"declaration","source":0,"src_end":11507,"src_start":11374},{"artifact":0,"gen_end":15898,"gen_start":15805,"node":49,"role":"declaration","source":0,"src_end":11636,"src_start":11509},{"artifact":0,"gen_end":16006,"gen_start":15898,"node":50,"role":"declaration","source":0,"src_end":11780,"src_start":11638},{"artifact":0,"gen_end":16111,"gen_start":16006,"node":51,"role":"declaration","source":0,"src_end":11921,"src_start":11782},{"artifact":0,"gen_end":16211,"gen_start":16111,"node":52,"role":"declaration","source":0,"src_end":12057,"src_start":11923},{"artifact":0,"gen_end":16311,"gen_start":16211,"node":53,"role":"declaration","source":0,"src_end":12193,"src_start":12059},{"artifact":0,"gen_end":16416,"gen_start":16311,"node":54,"role":"declaration","source":0,"src_end":12334,"src_start":12195},{"artifact":0,"gen_end":16510,"gen_start":16416,"node":55,"role":"declaration","source":0,"src_end":12464,"src_start":12336},{"artifact":0,"gen_end":16619,"gen_start":16510,"node":56,"role":"declaration","source":0,"src_end":12609,"src_start":12466},{"artifact":0,"gen_end":16721,"gen_start":16619,"node":57,"role":"declaration","source":0,"src_end":12747,"src_start":12611},{"artifact":0,"gen_end":16823,"gen_start":16721,"node":58,"role":"declaration","source":0,"src_end":12885,"src_start":12749},{"artifact":0,"gen_end":16932,"gen_start":16823,"node":59,"role":"declaration","source":0,"src_end":13030,"src_start":12887},{"artifact":0,"gen_end":17049,"gen_start":16932,"node":60,"role":"declaration","source":0,"src_end":13183,"src_start":13032},{"artifact":0,"gen_end":17155,"gen_start":17049,"node":61,"role":"declaration","source":0,"src_end":13325,"src_start":13185},{"artifact":0,"gen_end":17275,"gen_start":17155,"node":62,"role":"declaration","source":0,"src_end":13481,"src_start":13327},{"artifact":0,"gen_end":17456,"gen_start":17275,"node":63,"role":"declaration","source":0,"src_end":13712,"src_start":13483},{"artifact":0,"gen_end":17651,"gen_start":17456,"node":64,"role":"declaration","source":0,"src_end":13959,"src_start":13714},{"artifact":0,"gen_end":17668,"gen_start":17651,"node":0,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":65,"role":"declaration","source":0,"src_end":13995,"src_start":0},{"artifact":1,"gen_end":620,"gen_start":134,"node":66,"role":"declaration","source":0,"src_end":541,"src_start":295},{"artifact":1,"gen_end":1171,"gen_start":620,"node":67,"role":"declaration","source":0,"src_end":855,"src_start":543},{"artifact":1,"gen_end":1732,"gen_start":1171,"node":68,"role":"declaration","source":0,"src_end":1179,"src_start":857},{"artifact":1,"gen_end":2289,"gen_start":1732,"node":69,"role":"declaration","source":0,"src_end":1493,"src_start":1181},{"artifact":1,"gen_end":2888,"gen_start":2289,"node":70,"role":"declaration","source":0,"src_end":1828,"src_start":1495},{"artifact":1,"gen_end":3094,"gen_start":2888,"node":71,"role":"declaration","source":0,"src_end":1976,"src_start":1830},{"artifact":1,"gen_end":3594,"gen_start":3094,"node":72,"role":"declaration","source":0,"src_end":2307,"src_start":1978},{"artifact":1,"gen_end":3820,"gen_start":3594,"node":73,"role":"declaration","source":0,"src_end":2459,"src_start":2309},{"artifact":1,"gen_end":4052,"gen_start":3820,"node":74,"role":"declaration","source":0,"src_end":2619,"src_start":2461},{"artifact":1,"gen_end":4621,"gen_start":4052,"node":75,"role":"declaration","source":0,"src_end":2935,"src_start":2621},{"artifact":1,"gen_end":5208,"gen_start":4621,"node":76,"role":"declaration","source":0,"src_end":3269,"src_start":2937},{"artifact":1,"gen_end":5728,"gen_start":5208,"node":77,"role":"declaration","source":0,"src_end":3548,"src_start":3271},{"artifact":1,"gen_end":6135,"gen_start":5728,"node":78,"role":"declaration","source":0,"src_end":3754,"src_start":3550},{"artifact":1,"gen_end":6715,"gen_start":6135,"node":79,"role":"declaration","source":0,"src_end":4079,"src_start":3756},{"artifact":1,"gen_end":7144,"gen_start":6715,"node":80,"role":"declaration","source":0,"src_end":4298,"src_start":4081},{"artifact":1,"gen_end":7581,"gen_start":7144,"node":81,"role":"declaration","source":0,"src_end":4525,"src_start":4300},{"artifact":1,"gen_end":8070,"gen_start":7581,"node":82,"role":"declaration","source":0,"src_end":4780,"src_start":4527},{"artifact":1,"gen_end":8566,"gen_start":8070,"node":83,"role":"declaration","source":0,"src_end":5035,"src_start":4782},{"artifact":1,"gen_end":9044,"gen_start":8566,"node":84,"role":"declaration","source":0,"src_end":5286,"src_start":5037},{"artifact":1,"gen_end":9549,"gen_start":9044,"node":85,"role":"declaration","source":0,"src_end":5562,"src_start":5288},{"artifact":1,"gen_end":10046,"gen_start":9549,"node":86,"role":"declaration","source":0,"src_end":5830,"src_start":5564},{"artifact":1,"gen_end":10547,"gen_start":10046,"node":87,"role":"declaration","source":0,"src_end":6102,"src_start":5832},{"artifact":1,"gen_end":10980,"gen_start":10547,"node":88,"role":"declaration","source":0,"src_end":6332,"src_start":6104},{"artifact":1,"gen_end":11453,"gen_start":10980,"node":89,"role":"declaration","source":0,"src_end":6601,"src_start":6334},{"artifact":1,"gen_end":11910,"gen_start":11453,"node":90,"role":"declaration","source":0,"src_end":6857,"src_start":6603},{"artifact":1,"gen_end":12479,"gen_start":11910,"node":91,"role":"declaration","source":0,"src_end":7211,"src_start":6859},{"artifact":1,"gen_end":13146,"gen_start":12479,"node":92,"role":"declaration","source":0,"src_end":7650,"src_start":7213},{"artifact":1,"gen_end":13735,"gen_start":13146,"node":93,"role":"declaration","source":0,"src_end":8018,"src_start":7652},{"artifact":1,"gen_end":14364,"gen_start":13735,"node":94,"role":"declaration","source":0,"src_end":8424,"src_start":8020},{"artifact":1,"gen_end":15040,"gen_start":14364,"node":95,"role":"declaration","source":0,"src_end":8886,"src_start":8426},{"artifact":1,"gen_end":15683,"gen_start":15040,"node":96,"role":"declaration","source":0,"src_end":9315,"src_start":8888},{"artifact":1,"gen_end":15876,"gen_start":15683,"node":97,"role":"declaration","source":0,"src_end":9437,"src_start":9317},{"artifact":1,"gen_end":16076,"gen_start":15876,"node":98,"role":"declaration","source":0,"src_end":9565,"src_start":9439},{"artifact":1,"gen_end":16282,"gen_start":16076,"node":99,"role":"declaration","source":0,"src_end":9699,"src_start":9567},{"artifact":1,"gen_end":16482,"gen_start":16282,"node":100,"role":"declaration","source":0,"src_end":9827,"src_start":9701},{"artifact":1,"gen_end":16681,"gen_start":16482,"node":101,"role":"declaration","source":0,"src_end":9954,"src_start":9829},{"artifact":1,"gen_end":16887,"gen_start":16681,"node":102,"role":"declaration","source":0,"src_end":10087,"src_start":9956},{"artifact":1,"gen_end":17078,"gen_start":16887,"node":103,"role":"declaration","source":0,"src_end":10209,"src_start":10089},{"artifact":1,"gen_end":17282,"gen_start":17078,"node":104,"role":"declaration","source":0,"src_end":10343,"src_start":10211},{"artifact":1,"gen_end":17494,"gen_start":17282,"node":105,"role":"declaration","source":0,"src_end":10485,"src_start":10345},{"artifact":1,"gen_end":17684,"gen_start":17494,"node":106,"role":"declaration","source":0,"src_end":10604,"src_start":10487},{"artifact":1,"gen_end":17885,"gen_start":17684,"node":107,"role":"declaration","source":0,"src_end":10733,"src_start":10606},{"artifact":1,"gen_end":18081,"gen_start":17885,"node":108,"role":"declaration","source":0,"src_end":10857,"src_start":10735},{"artifact":1,"gen_end":18270,"gen_start":18081,"node":109,"role":"declaration","source":0,"src_end":10977,"src_start":10859},{"artifact":1,"gen_end":18458,"gen_start":18270,"node":110,"role":"declaration","source":0,"src_end":11096,"src_start":10979},{"artifact":1,"gen_end":18675,"gen_start":18458,"node":111,"role":"declaration","source":0,"src_end":11242,"src_start":11098},{"artifact":1,"gen_end":18876,"gen_start":18675,"node":112,"role":"declaration","source":0,"src_end":11372,"src_start":11244},{"artifact":1,"gen_end":19083,"gen_start":18876,"node":113,"role":"declaration","source":0,"src_end":11507,"src_start":11374},{"artifact":1,"gen_end":19284,"gen_start":19083,"node":114,"role":"declaration","source":0,"src_end":11636,"src_start":11509},{"artifact":1,"gen_end":19500,"gen_start":19284,"node":115,"role":"declaration","source":0,"src_end":11780,"src_start":11638},{"artifact":1,"gen_end":19714,"gen_start":19500,"node":116,"role":"declaration","source":0,"src_end":11921,"src_start":11782},{"artifact":1,"gen_end":19922,"gen_start":19714,"node":117,"role":"declaration","source":0,"src_end":12057,"src_start":11923},{"artifact":1,"gen_end":20130,"gen_start":19922,"node":118,"role":"declaration","source":0,"src_end":12193,"src_start":12059},{"artifact":1,"gen_end":20343,"gen_start":20130,"node":119,"role":"declaration","source":0,"src_end":12334,"src_start":12195},{"artifact":1,"gen_end":20544,"gen_start":20343,"node":120,"role":"declaration","source":0,"src_end":12464,"src_start":12336},{"artifact":1,"gen_end":20762,"gen_start":20544,"node":121,"role":"declaration","source":0,"src_end":12609,"src_start":12466},{"artifact":1,"gen_end":20972,"gen_start":20762,"node":122,"role":"declaration","source":0,"src_end":12747,"src_start":12611},{"artifact":1,"gen_end":21182,"gen_start":20972,"node":123,"role":"declaration","source":0,"src_end":12885,"src_start":12749},{"artifact":1,"gen_end":21400,"gen_start":21182,"node":124,"role":"declaration","source":0,"src_end":13030,"src_start":12887},{"artifact":1,"gen_end":21626,"gen_start":21400,"node":125,"role":"declaration","source":0,"src_end":13183,"src_start":13032},{"artifact":1,"gen_end":21840,"gen_start":21626,"node":126,"role":"declaration","source":0,"src_end":13325,"src_start":13185},{"artifact":1,"gen_end":22069,"gen_start":21840,"node":127,"role":"declaration","source":0,"src_end":13481,"src_start":13327},{"artifact":1,"gen_end":22357,"gen_start":22069,"node":128,"role":"declaration","source":0,"src_end":13712,"src_start":13483},{"artifact":1,"gen_end":22660,"gen_start":22357,"node":129,"role":"declaration","source":0,"src_end":13959,"src_start":13714},{"artifact":1,"gen_end":22675,"gen_start":22660,"node":65,"role":"declaration","source":0,"src_end":13995,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-latex-module"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"09fef2732bb2b95f41909df0570942389cddbf5bcefe01e667b6ec7400caad75"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Pipeline.map.json b/examples/models/expected/build/maps/Models/Pipeline.map.json index f88396eb7..957471d8f 100644 --- a/examples/models/expected/build/maps/Models/Pipeline.map.json +++ b/examples/models/expected/build/maps/Models/Pipeline.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Pipeline.lean"},{"id":1,"kind":"tex","path":"modules/Models/Pipeline.tex"}],"mappings":[{"artifact":0,"gen_end":492,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":0,"gen_end":618,"gen_start":492,"node":1,"role":"declaration","source":0,"src_end":394,"src_start":258},{"artifact":0,"gen_end":866,"gen_start":618,"node":2,"role":"declaration","source":0,"src_end":673,"src_start":396},{"artifact":0,"gen_end":1043,"gen_start":866,"node":3,"role":"declaration","source":0,"src_end":985,"src_start":675},{"artifact":0,"gen_end":1437,"gen_start":1043,"node":4,"role":"declaration","source":0,"src_end":1718,"src_start":987},{"artifact":0,"gen_end":1680,"gen_start":1437,"node":5,"role":"declaration","source":0,"src_end":2061,"src_start":1720},{"artifact":0,"gen_end":4805,"gen_start":1680,"node":6,"role":"declaration","source":0,"src_end":2302,"src_start":2063},{"artifact":0,"gen_end":5187,"gen_start":4805,"node":7,"role":"declaration","source":0,"src_end":3033,"src_start":2304},{"artifact":0,"gen_end":5395,"gen_start":5187,"node":8,"role":"declaration","source":0,"src_end":3233,"src_start":3035},{"artifact":0,"gen_end":5520,"gen_start":5395,"node":9,"role":"declaration","source":0,"src_end":3436,"src_start":3235},{"artifact":0,"gen_end":5678,"gen_start":5520,"node":10,"role":"declaration","source":0,"src_end":3647,"src_start":3438},{"artifact":0,"gen_end":5847,"gen_start":5678,"node":11,"role":"declaration","source":0,"src_end":3827,"src_start":3649},{"artifact":0,"gen_end":5848,"gen_start":5847,"node":12,"role":"declaration","source":0,"src_end":4052,"src_start":3829},{"artifact":0,"gen_end":6237,"gen_start":5848,"node":13,"role":"declaration","source":0,"src_end":4397,"src_start":4054},{"artifact":0,"gen_end":6618,"gen_start":6237,"node":14,"role":"declaration","source":0,"src_end":5127,"src_start":4399},{"artifact":0,"gen_end":6822,"gen_start":6618,"node":15,"role":"declaration","source":0,"src_end":5324,"src_start":5129},{"artifact":0,"gen_end":6975,"gen_start":6822,"node":16,"role":"declaration","source":0,"src_end":5525,"src_start":5326},{"artifact":0,"gen_end":7086,"gen_start":6975,"node":17,"role":"declaration","source":0,"src_end":5648,"src_start":5527},{"artifact":0,"gen_end":7087,"gen_start":7086,"node":18,"role":"declaration","source":0,"src_end":5791,"src_start":5650},{"artifact":0,"gen_end":7198,"gen_start":7087,"node":19,"role":"declaration","source":0,"src_end":5975,"src_start":5793},{"artifact":0,"gen_end":7531,"gen_start":7198,"node":20,"role":"declaration","source":0,"src_end":6710,"src_start":5977},{"artifact":0,"gen_end":7698,"gen_start":7531,"node":21,"role":"declaration","source":0,"src_end":6882,"src_start":6712},{"artifact":0,"gen_end":7815,"gen_start":7698,"node":22,"role":"declaration","source":0,"src_end":7034,"src_start":6884},{"artifact":0,"gen_end":8000,"gen_start":7815,"node":23,"role":"declaration","source":0,"src_end":7226,"src_start":7036},{"artifact":0,"gen_end":8001,"gen_start":8000,"node":24,"role":"declaration","source":0,"src_end":7379,"src_start":7228},{"artifact":0,"gen_end":8166,"gen_start":8001,"node":25,"role":"declaration","source":0,"src_end":7642,"src_start":7381},{"artifact":0,"gen_end":8503,"gen_start":8166,"node":26,"role":"declaration","source":0,"src_end":8402,"src_start":7644},{"artifact":0,"gen_end":8675,"gen_start":8503,"node":27,"role":"declaration","source":0,"src_end":8592,"src_start":8404},{"artifact":0,"gen_end":8803,"gen_start":8675,"node":28,"role":"declaration","source":0,"src_end":8759,"src_start":8594},{"artifact":0,"gen_end":9011,"gen_start":8803,"node":29,"role":"declaration","source":0,"src_end":8974,"src_start":8761},{"artifact":0,"gen_end":9012,"gen_start":9011,"node":30,"role":"declaration","source":0,"src_end":9143,"src_start":8976},{"artifact":0,"gen_end":9217,"gen_start":9012,"node":31,"role":"declaration","source":0,"src_end":9385,"src_start":9145},{"artifact":0,"gen_end":9450,"gen_start":9217,"node":32,"role":"declaration","source":0,"src_end":9705,"src_start":9387},{"artifact":0,"gen_end":9613,"gen_start":9450,"node":33,"role":"declaration","source":0,"src_end":9866,"src_start":9707},{"artifact":0,"gen_end":9768,"gen_start":9613,"node":34,"role":"declaration","source":0,"src_end":10004,"src_start":9868},{"artifact":0,"gen_end":9878,"gen_start":9768,"node":35,"role":"declaration","source":0,"src_end":10126,"src_start":10006},{"artifact":0,"gen_end":9879,"gen_start":9878,"node":36,"role":"declaration","source":0,"src_end":10269,"src_start":10128},{"artifact":0,"gen_end":10070,"gen_start":9879,"node":37,"role":"declaration","source":0,"src_end":10578,"src_start":10271},{"artifact":0,"gen_end":10405,"gen_start":10070,"node":38,"role":"declaration","source":0,"src_end":11336,"src_start":10580},{"artifact":0,"gen_end":10573,"gen_start":10405,"node":39,"role":"declaration","source":0,"src_end":11522,"src_start":11338},{"artifact":0,"gen_end":10684,"gen_start":10573,"node":40,"role":"declaration","source":0,"src_end":11685,"src_start":11524},{"artifact":0,"gen_end":10808,"gen_start":10684,"node":41,"role":"declaration","source":0,"src_end":11817,"src_start":11687},{"artifact":0,"gen_end":10935,"gen_start":10808,"node":42,"role":"declaration","source":0,"src_end":11974,"src_start":11819},{"artifact":0,"gen_end":14023,"gen_start":10935,"node":43,"role":"declaration","source":0,"src_end":12235,"src_start":11976},{"artifact":0,"gen_end":14209,"gen_start":14023,"node":44,"role":"declaration","source":0,"src_end":12562,"src_start":12237},{"artifact":0,"gen_end":15333,"gen_start":14209,"node":45,"role":"declaration","source":0,"src_end":12809,"src_start":12564},{"artifact":0,"gen_end":15474,"gen_start":15333,"node":46,"role":"declaration","source":0,"src_end":12909,"src_start":12811},{"artifact":0,"gen_end":15495,"gen_start":15474,"node":0,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":47,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":48,"role":"declaration","source":0,"src_end":394,"src_start":258},{"artifact":1,"gen_end":769,"gen_start":430,"node":49,"role":"declaration","source":0,"src_end":673,"src_start":396},{"artifact":1,"gen_end":1611,"gen_start":769,"node":50,"role":"declaration","source":0,"src_end":985,"src_start":675},{"artifact":1,"gen_end":1974,"gen_start":1611,"node":51,"role":"declaration","source":0,"src_end":1718,"src_start":987},{"artifact":1,"gen_end":2951,"gen_start":1974,"node":52,"role":"declaration","source":0,"src_end":2061,"src_start":1720},{"artifact":1,"gen_end":3273,"gen_start":2951,"node":53,"role":"declaration","source":0,"src_end":2302,"src_start":2063},{"artifact":1,"gen_end":3624,"gen_start":3273,"node":54,"role":"declaration","source":0,"src_end":3033,"src_start":2304},{"artifact":1,"gen_end":4369,"gen_start":3624,"node":55,"role":"declaration","source":0,"src_end":3233,"src_start":3035},{"artifact":1,"gen_end":5123,"gen_start":4369,"node":56,"role":"declaration","source":0,"src_end":3436,"src_start":3235},{"artifact":1,"gen_end":5530,"gen_start":5123,"node":57,"role":"declaration","source":0,"src_end":3647,"src_start":3438},{"artifact":1,"gen_end":5870,"gen_start":5530,"node":58,"role":"declaration","source":0,"src_end":3827,"src_start":3649},{"artifact":1,"gen_end":6237,"gen_start":5870,"node":59,"role":"declaration","source":0,"src_end":4052,"src_start":3829},{"artifact":1,"gen_end":7103,"gen_start":6237,"node":60,"role":"declaration","source":0,"src_end":4397,"src_start":4054},{"artifact":1,"gen_end":7453,"gen_start":7103,"node":61,"role":"declaration","source":0,"src_end":5127,"src_start":4399},{"artifact":1,"gen_end":8190,"gen_start":7453,"node":62,"role":"declaration","source":0,"src_end":5324,"src_start":5129},{"artifact":1,"gen_end":8970,"gen_start":8190,"node":63,"role":"declaration","source":0,"src_end":5525,"src_start":5326},{"artifact":1,"gen_end":9251,"gen_start":8970,"node":64,"role":"declaration","source":0,"src_end":5648,"src_start":5527},{"artifact":1,"gen_end":9507,"gen_start":9251,"node":65,"role":"declaration","source":0,"src_end":5791,"src_start":5650},{"artifact":1,"gen_end":9989,"gen_start":9507,"node":66,"role":"declaration","source":0,"src_end":5975,"src_start":5793},{"artifact":1,"gen_end":10245,"gen_start":9989,"node":67,"role":"declaration","source":0,"src_end":6710,"src_start":5977},{"artifact":1,"gen_end":10881,"gen_start":10245,"node":68,"role":"declaration","source":0,"src_end":6882,"src_start":6712},{"artifact":1,"gen_end":11318,"gen_start":10881,"node":69,"role":"declaration","source":0,"src_end":7034,"src_start":6884},{"artifact":1,"gen_end":11689,"gen_start":11318,"node":70,"role":"declaration","source":0,"src_end":7226,"src_start":7036},{"artifact":1,"gen_end":11962,"gen_start":11689,"node":71,"role":"declaration","source":0,"src_end":7379,"src_start":7228},{"artifact":1,"gen_end":12512,"gen_start":11962,"node":72,"role":"declaration","source":0,"src_end":7642,"src_start":7381},{"artifact":1,"gen_end":12783,"gen_start":12512,"node":73,"role":"declaration","source":0,"src_end":8402,"src_start":7644},{"artifact":1,"gen_end":13431,"gen_start":12783,"node":74,"role":"declaration","source":0,"src_end":8592,"src_start":8404},{"artifact":1,"gen_end":13884,"gen_start":13431,"node":75,"role":"declaration","source":0,"src_end":8759,"src_start":8594},{"artifact":1,"gen_end":14278,"gen_start":13884,"node":76,"role":"declaration","source":0,"src_end":8974,"src_start":8761},{"artifact":1,"gen_end":14580,"gen_start":14278,"node":77,"role":"declaration","source":0,"src_end":9143,"src_start":8976},{"artifact":1,"gen_end":15157,"gen_start":14580,"node":78,"role":"declaration","source":0,"src_end":9385,"src_start":9145},{"artifact":1,"gen_end":15446,"gen_start":15157,"node":79,"role":"declaration","source":0,"src_end":9705,"src_start":9387},{"artifact":1,"gen_end":16098,"gen_start":15446,"node":80,"role":"declaration","source":0,"src_end":9866,"src_start":9707},{"artifact":1,"gen_end":16559,"gen_start":16098,"node":81,"role":"declaration","source":0,"src_end":10004,"src_start":9868},{"artifact":1,"gen_end":16839,"gen_start":16559,"node":82,"role":"declaration","source":0,"src_end":10126,"src_start":10006},{"artifact":1,"gen_end":17095,"gen_start":16839,"node":83,"role":"declaration","source":0,"src_end":10269,"src_start":10128},{"artifact":1,"gen_end":17683,"gen_start":17095,"node":84,"role":"declaration","source":0,"src_end":10578,"src_start":10271},{"artifact":1,"gen_end":17952,"gen_start":17683,"node":85,"role":"declaration","source":0,"src_end":11336,"src_start":10580},{"artifact":1,"gen_end":18591,"gen_start":17952,"node":86,"role":"declaration","source":0,"src_end":11522,"src_start":11338},{"artifact":1,"gen_end":19023,"gen_start":18591,"node":87,"role":"declaration","source":0,"src_end":11685,"src_start":11524},{"artifact":1,"gen_end":19318,"gen_start":19023,"node":88,"role":"declaration","source":0,"src_end":11817,"src_start":11687},{"artifact":1,"gen_end":19692,"gen_start":19318,"node":89,"role":"declaration","source":0,"src_end":11974,"src_start":11819},{"artifact":1,"gen_end":19998,"gen_start":19692,"node":90,"role":"declaration","source":0,"src_end":12235,"src_start":11976},{"artifact":1,"gen_end":20752,"gen_start":19998,"node":91,"role":"declaration","source":0,"src_end":12562,"src_start":12237},{"artifact":1,"gen_end":22333,"gen_start":20752,"node":92,"role":"declaration","source":0,"src_end":12809,"src_start":12564},{"artifact":1,"gen_end":22789,"gen_start":22333,"node":93,"role":"declaration","source":0,"src_end":12909,"src_start":12811},{"artifact":1,"gen_end":22804,"gen_start":22789,"node":47,"role":"declaration","source":0,"src_end":12945,"src_start":0}],"module":"Pipeline","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-latex-module"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Pipeline.lex.tex","sha256":"82cec7477a537982dab7be86130292d11e3cc2123c2e7188a32b8d8808ab22c1"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Pipeline.lean"},{"id":1,"kind":"tex","path":"modules/Models/Pipeline.tex"}],"mappings":[{"artifact":0,"gen_end":492,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":0,"gen_end":618,"gen_start":492,"node":1,"role":"declaration","source":0,"src_end":394,"src_start":258},{"artifact":0,"gen_end":866,"gen_start":618,"node":2,"role":"declaration","source":0,"src_end":673,"src_start":396},{"artifact":0,"gen_end":1043,"gen_start":866,"node":3,"role":"declaration","source":0,"src_end":985,"src_start":675},{"artifact":0,"gen_end":1437,"gen_start":1043,"node":4,"role":"declaration","source":0,"src_end":1718,"src_start":987},{"artifact":0,"gen_end":1680,"gen_start":1437,"node":5,"role":"declaration","source":0,"src_end":2061,"src_start":1720},{"artifact":0,"gen_end":4805,"gen_start":1680,"node":6,"role":"declaration","source":0,"src_end":2302,"src_start":2063},{"artifact":0,"gen_end":5187,"gen_start":4805,"node":7,"role":"declaration","source":0,"src_end":3033,"src_start":2304},{"artifact":0,"gen_end":5395,"gen_start":5187,"node":8,"role":"declaration","source":0,"src_end":3233,"src_start":3035},{"artifact":0,"gen_end":5520,"gen_start":5395,"node":9,"role":"declaration","source":0,"src_end":3436,"src_start":3235},{"artifact":0,"gen_end":5678,"gen_start":5520,"node":10,"role":"declaration","source":0,"src_end":3647,"src_start":3438},{"artifact":0,"gen_end":5847,"gen_start":5678,"node":11,"role":"declaration","source":0,"src_end":3827,"src_start":3649},{"artifact":0,"gen_end":5848,"gen_start":5847,"node":12,"role":"declaration","source":0,"src_end":4052,"src_start":3829},{"artifact":0,"gen_end":6237,"gen_start":5848,"node":13,"role":"declaration","source":0,"src_end":4397,"src_start":4054},{"artifact":0,"gen_end":6618,"gen_start":6237,"node":14,"role":"declaration","source":0,"src_end":5127,"src_start":4399},{"artifact":0,"gen_end":6822,"gen_start":6618,"node":15,"role":"declaration","source":0,"src_end":5324,"src_start":5129},{"artifact":0,"gen_end":6975,"gen_start":6822,"node":16,"role":"declaration","source":0,"src_end":5525,"src_start":5326},{"artifact":0,"gen_end":7086,"gen_start":6975,"node":17,"role":"declaration","source":0,"src_end":5648,"src_start":5527},{"artifact":0,"gen_end":7087,"gen_start":7086,"node":18,"role":"declaration","source":0,"src_end":5791,"src_start":5650},{"artifact":0,"gen_end":7198,"gen_start":7087,"node":19,"role":"declaration","source":0,"src_end":5975,"src_start":5793},{"artifact":0,"gen_end":7531,"gen_start":7198,"node":20,"role":"declaration","source":0,"src_end":6710,"src_start":5977},{"artifact":0,"gen_end":7698,"gen_start":7531,"node":21,"role":"declaration","source":0,"src_end":6882,"src_start":6712},{"artifact":0,"gen_end":7815,"gen_start":7698,"node":22,"role":"declaration","source":0,"src_end":7034,"src_start":6884},{"artifact":0,"gen_end":8000,"gen_start":7815,"node":23,"role":"declaration","source":0,"src_end":7226,"src_start":7036},{"artifact":0,"gen_end":8001,"gen_start":8000,"node":24,"role":"declaration","source":0,"src_end":7379,"src_start":7228},{"artifact":0,"gen_end":8166,"gen_start":8001,"node":25,"role":"declaration","source":0,"src_end":7642,"src_start":7381},{"artifact":0,"gen_end":8503,"gen_start":8166,"node":26,"role":"declaration","source":0,"src_end":8402,"src_start":7644},{"artifact":0,"gen_end":8675,"gen_start":8503,"node":27,"role":"declaration","source":0,"src_end":8592,"src_start":8404},{"artifact":0,"gen_end":8803,"gen_start":8675,"node":28,"role":"declaration","source":0,"src_end":8759,"src_start":8594},{"artifact":0,"gen_end":9011,"gen_start":8803,"node":29,"role":"declaration","source":0,"src_end":8974,"src_start":8761},{"artifact":0,"gen_end":9012,"gen_start":9011,"node":30,"role":"declaration","source":0,"src_end":9143,"src_start":8976},{"artifact":0,"gen_end":9217,"gen_start":9012,"node":31,"role":"declaration","source":0,"src_end":9385,"src_start":9145},{"artifact":0,"gen_end":9450,"gen_start":9217,"node":32,"role":"declaration","source":0,"src_end":9705,"src_start":9387},{"artifact":0,"gen_end":9613,"gen_start":9450,"node":33,"role":"declaration","source":0,"src_end":9866,"src_start":9707},{"artifact":0,"gen_end":9768,"gen_start":9613,"node":34,"role":"declaration","source":0,"src_end":10004,"src_start":9868},{"artifact":0,"gen_end":9878,"gen_start":9768,"node":35,"role":"declaration","source":0,"src_end":10126,"src_start":10006},{"artifact":0,"gen_end":9879,"gen_start":9878,"node":36,"role":"declaration","source":0,"src_end":10269,"src_start":10128},{"artifact":0,"gen_end":10070,"gen_start":9879,"node":37,"role":"declaration","source":0,"src_end":10578,"src_start":10271},{"artifact":0,"gen_end":10405,"gen_start":10070,"node":38,"role":"declaration","source":0,"src_end":11336,"src_start":10580},{"artifact":0,"gen_end":10573,"gen_start":10405,"node":39,"role":"declaration","source":0,"src_end":11522,"src_start":11338},{"artifact":0,"gen_end":10684,"gen_start":10573,"node":40,"role":"declaration","source":0,"src_end":11685,"src_start":11524},{"artifact":0,"gen_end":10808,"gen_start":10684,"node":41,"role":"declaration","source":0,"src_end":11817,"src_start":11687},{"artifact":0,"gen_end":10935,"gen_start":10808,"node":42,"role":"declaration","source":0,"src_end":11974,"src_start":11819},{"artifact":0,"gen_end":14023,"gen_start":10935,"node":43,"role":"declaration","source":0,"src_end":12235,"src_start":11976},{"artifact":0,"gen_end":14209,"gen_start":14023,"node":44,"role":"declaration","source":0,"src_end":12562,"src_start":12237},{"artifact":0,"gen_end":15333,"gen_start":14209,"node":45,"role":"declaration","source":0,"src_end":12809,"src_start":12564},{"artifact":0,"gen_end":15474,"gen_start":15333,"node":46,"role":"declaration","source":0,"src_end":12909,"src_start":12811},{"artifact":0,"gen_end":15495,"gen_start":15474,"node":0,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":47,"role":"declaration","source":0,"src_end":12945,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":48,"role":"declaration","source":0,"src_end":394,"src_start":258},{"artifact":1,"gen_end":769,"gen_start":430,"node":49,"role":"declaration","source":0,"src_end":673,"src_start":396},{"artifact":1,"gen_end":1611,"gen_start":769,"node":50,"role":"declaration","source":0,"src_end":985,"src_start":675},{"artifact":1,"gen_end":1974,"gen_start":1611,"node":51,"role":"declaration","source":0,"src_end":1718,"src_start":987},{"artifact":1,"gen_end":2951,"gen_start":1974,"node":52,"role":"declaration","source":0,"src_end":2061,"src_start":1720},{"artifact":1,"gen_end":3273,"gen_start":2951,"node":53,"role":"declaration","source":0,"src_end":2302,"src_start":2063},{"artifact":1,"gen_end":3624,"gen_start":3273,"node":54,"role":"declaration","source":0,"src_end":3033,"src_start":2304},{"artifact":1,"gen_end":4369,"gen_start":3624,"node":55,"role":"declaration","source":0,"src_end":3233,"src_start":3035},{"artifact":1,"gen_end":5123,"gen_start":4369,"node":56,"role":"declaration","source":0,"src_end":3436,"src_start":3235},{"artifact":1,"gen_end":5530,"gen_start":5123,"node":57,"role":"declaration","source":0,"src_end":3647,"src_start":3438},{"artifact":1,"gen_end":5870,"gen_start":5530,"node":58,"role":"declaration","source":0,"src_end":3827,"src_start":3649},{"artifact":1,"gen_end":6237,"gen_start":5870,"node":59,"role":"declaration","source":0,"src_end":4052,"src_start":3829},{"artifact":1,"gen_end":7103,"gen_start":6237,"node":60,"role":"declaration","source":0,"src_end":4397,"src_start":4054},{"artifact":1,"gen_end":7453,"gen_start":7103,"node":61,"role":"declaration","source":0,"src_end":5127,"src_start":4399},{"artifact":1,"gen_end":8190,"gen_start":7453,"node":62,"role":"declaration","source":0,"src_end":5324,"src_start":5129},{"artifact":1,"gen_end":8970,"gen_start":8190,"node":63,"role":"declaration","source":0,"src_end":5525,"src_start":5326},{"artifact":1,"gen_end":9251,"gen_start":8970,"node":64,"role":"declaration","source":0,"src_end":5648,"src_start":5527},{"artifact":1,"gen_end":9507,"gen_start":9251,"node":65,"role":"declaration","source":0,"src_end":5791,"src_start":5650},{"artifact":1,"gen_end":9989,"gen_start":9507,"node":66,"role":"declaration","source":0,"src_end":5975,"src_start":5793},{"artifact":1,"gen_end":10245,"gen_start":9989,"node":67,"role":"declaration","source":0,"src_end":6710,"src_start":5977},{"artifact":1,"gen_end":10881,"gen_start":10245,"node":68,"role":"declaration","source":0,"src_end":6882,"src_start":6712},{"artifact":1,"gen_end":11318,"gen_start":10881,"node":69,"role":"declaration","source":0,"src_end":7034,"src_start":6884},{"artifact":1,"gen_end":11689,"gen_start":11318,"node":70,"role":"declaration","source":0,"src_end":7226,"src_start":7036},{"artifact":1,"gen_end":11962,"gen_start":11689,"node":71,"role":"declaration","source":0,"src_end":7379,"src_start":7228},{"artifact":1,"gen_end":12512,"gen_start":11962,"node":72,"role":"declaration","source":0,"src_end":7642,"src_start":7381},{"artifact":1,"gen_end":12783,"gen_start":12512,"node":73,"role":"declaration","source":0,"src_end":8402,"src_start":7644},{"artifact":1,"gen_end":13431,"gen_start":12783,"node":74,"role":"declaration","source":0,"src_end":8592,"src_start":8404},{"artifact":1,"gen_end":13884,"gen_start":13431,"node":75,"role":"declaration","source":0,"src_end":8759,"src_start":8594},{"artifact":1,"gen_end":14278,"gen_start":13884,"node":76,"role":"declaration","source":0,"src_end":8974,"src_start":8761},{"artifact":1,"gen_end":14580,"gen_start":14278,"node":77,"role":"declaration","source":0,"src_end":9143,"src_start":8976},{"artifact":1,"gen_end":15157,"gen_start":14580,"node":78,"role":"declaration","source":0,"src_end":9385,"src_start":9145},{"artifact":1,"gen_end":15446,"gen_start":15157,"node":79,"role":"declaration","source":0,"src_end":9705,"src_start":9387},{"artifact":1,"gen_end":16098,"gen_start":15446,"node":80,"role":"declaration","source":0,"src_end":9866,"src_start":9707},{"artifact":1,"gen_end":16559,"gen_start":16098,"node":81,"role":"declaration","source":0,"src_end":10004,"src_start":9868},{"artifact":1,"gen_end":16839,"gen_start":16559,"node":82,"role":"declaration","source":0,"src_end":10126,"src_start":10006},{"artifact":1,"gen_end":17095,"gen_start":16839,"node":83,"role":"declaration","source":0,"src_end":10269,"src_start":10128},{"artifact":1,"gen_end":17683,"gen_start":17095,"node":84,"role":"declaration","source":0,"src_end":10578,"src_start":10271},{"artifact":1,"gen_end":17952,"gen_start":17683,"node":85,"role":"declaration","source":0,"src_end":11336,"src_start":10580},{"artifact":1,"gen_end":18591,"gen_start":17952,"node":86,"role":"declaration","source":0,"src_end":11522,"src_start":11338},{"artifact":1,"gen_end":19023,"gen_start":18591,"node":87,"role":"declaration","source":0,"src_end":11685,"src_start":11524},{"artifact":1,"gen_end":19318,"gen_start":19023,"node":88,"role":"declaration","source":0,"src_end":11817,"src_start":11687},{"artifact":1,"gen_end":19692,"gen_start":19318,"node":89,"role":"declaration","source":0,"src_end":11974,"src_start":11819},{"artifact":1,"gen_end":19998,"gen_start":19692,"node":90,"role":"declaration","source":0,"src_end":12235,"src_start":11976},{"artifact":1,"gen_end":20752,"gen_start":19998,"node":91,"role":"declaration","source":0,"src_end":12562,"src_start":12237},{"artifact":1,"gen_end":22333,"gen_start":20752,"node":92,"role":"declaration","source":0,"src_end":12809,"src_start":12564},{"artifact":1,"gen_end":22789,"gen_start":22333,"node":93,"role":"declaration","source":0,"src_end":12909,"src_start":12811},{"artifact":1,"gen_end":22804,"gen_start":22789,"node":47,"role":"declaration","source":0,"src_end":12945,"src_start":0}],"module":"Pipeline","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-latex-module"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Pipeline.lex.tex","sha256":"82cec7477a537982dab7be86130292d11e3cc2123c2e7188a32b8d8808ab22c1"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Policy.map.json b/examples/models/expected/build/maps/Models/Policy.map.json index 4a432444b..98dc3dcec 100644 --- a/examples/models/expected/build/maps/Models/Policy.map.json +++ b/examples/models/expected/build/maps/Models/Policy.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Policy.lean"},{"id":1,"kind":"tex","path":"modules/Models/Policy.tex"}],"mappings":[{"artifact":0,"gen_end":260,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":0,"gen_end":467,"gen_start":260,"node":1,"role":"declaration","source":0,"src_end":404,"src_start":165},{"artifact":0,"gen_end":593,"gen_start":467,"node":2,"role":"declaration","source":0,"src_end":538,"src_start":406},{"artifact":0,"gen_end":706,"gen_start":593,"node":3,"role":"declaration","source":0,"src_end":693,"src_start":540},{"artifact":0,"gen_end":938,"gen_start":706,"node":4,"role":"declaration","source":0,"src_end":1091,"src_start":695},{"artifact":0,"gen_end":1173,"gen_start":938,"node":5,"role":"declaration","source":0,"src_end":1492,"src_start":1093},{"artifact":0,"gen_end":1286,"gen_start":1173,"node":6,"role":"declaration","source":0,"src_end":1617,"src_start":1494},{"artifact":0,"gen_end":1646,"gen_start":1286,"node":7,"role":"declaration","source":0,"src_end":1968,"src_start":1619},{"artifact":0,"gen_end":2002,"gen_start":1646,"node":8,"role":"declaration","source":0,"src_end":2270,"src_start":1970},{"artifact":0,"gen_end":2235,"gen_start":2002,"node":9,"role":"declaration","source":0,"src_end":2667,"src_start":2272},{"artifact":0,"gen_end":2348,"gen_start":2235,"node":10,"role":"declaration","source":0,"src_end":2819,"src_start":2669},{"artifact":0,"gen_end":2543,"gen_start":2348,"node":11,"role":"declaration","source":0,"src_end":2990,"src_start":2821},{"artifact":0,"gen_end":2654,"gen_start":2543,"node":12,"role":"declaration","source":0,"src_end":3136,"src_start":2992},{"artifact":0,"gen_end":2673,"gen_start":2654,"node":0,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":1,"gen_end":588,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":404,"src_start":165},{"artifact":1,"gen_end":885,"gen_start":588,"node":15,"role":"declaration","source":0,"src_end":538,"src_start":406},{"artifact":1,"gen_end":1245,"gen_start":885,"node":16,"role":"declaration","source":0,"src_end":693,"src_start":540},{"artifact":1,"gen_end":1532,"gen_start":1245,"node":17,"role":"declaration","source":0,"src_end":1091,"src_start":695},{"artifact":1,"gen_end":1822,"gen_start":1532,"node":18,"role":"declaration","source":0,"src_end":1492,"src_start":1093},{"artifact":1,"gen_end":2105,"gen_start":1822,"node":19,"role":"declaration","source":0,"src_end":1617,"src_start":1494},{"artifact":1,"gen_end":3224,"gen_start":2105,"node":20,"role":"declaration","source":0,"src_end":1968,"src_start":1619},{"artifact":1,"gen_end":4043,"gen_start":3224,"node":21,"role":"declaration","source":0,"src_end":2270,"src_start":1970},{"artifact":1,"gen_end":4330,"gen_start":4043,"node":22,"role":"declaration","source":0,"src_end":2667,"src_start":2272},{"artifact":1,"gen_end":4550,"gen_start":4330,"node":23,"role":"declaration","source":0,"src_end":2819,"src_start":2669},{"artifact":1,"gen_end":5218,"gen_start":4550,"node":24,"role":"declaration","source":0,"src_end":2990,"src_start":2821},{"artifact":1,"gen_end":5653,"gen_start":5218,"node":25,"role":"declaration","source":0,"src_end":3136,"src_start":2992},{"artifact":1,"gen_end":5668,"gen_start":5653,"node":13,"role":"declaration","source":0,"src_end":3172,"src_start":0}],"module":"Policy","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Policy.lex.tex","sha256":"32d2ea99e908b81d5210299ee8e6148cc87e4ae72d9bef235cadf5cf69947ecf"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Policy.lean"},{"id":1,"kind":"tex","path":"modules/Models/Policy.tex"}],"mappings":[{"artifact":0,"gen_end":260,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":0,"gen_end":467,"gen_start":260,"node":1,"role":"declaration","source":0,"src_end":404,"src_start":165},{"artifact":0,"gen_end":593,"gen_start":467,"node":2,"role":"declaration","source":0,"src_end":538,"src_start":406},{"artifact":0,"gen_end":706,"gen_start":593,"node":3,"role":"declaration","source":0,"src_end":693,"src_start":540},{"artifact":0,"gen_end":938,"gen_start":706,"node":4,"role":"declaration","source":0,"src_end":1091,"src_start":695},{"artifact":0,"gen_end":1173,"gen_start":938,"node":5,"role":"declaration","source":0,"src_end":1492,"src_start":1093},{"artifact":0,"gen_end":1286,"gen_start":1173,"node":6,"role":"declaration","source":0,"src_end":1617,"src_start":1494},{"artifact":0,"gen_end":1646,"gen_start":1286,"node":7,"role":"declaration","source":0,"src_end":1968,"src_start":1619},{"artifact":0,"gen_end":2002,"gen_start":1646,"node":8,"role":"declaration","source":0,"src_end":2270,"src_start":1970},{"artifact":0,"gen_end":2235,"gen_start":2002,"node":9,"role":"declaration","source":0,"src_end":2667,"src_start":2272},{"artifact":0,"gen_end":2348,"gen_start":2235,"node":10,"role":"declaration","source":0,"src_end":2819,"src_start":2669},{"artifact":0,"gen_end":2543,"gen_start":2348,"node":11,"role":"declaration","source":0,"src_end":2990,"src_start":2821},{"artifact":0,"gen_end":2654,"gen_start":2543,"node":12,"role":"declaration","source":0,"src_end":3136,"src_start":2992},{"artifact":0,"gen_end":2673,"gen_start":2654,"node":0,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3172,"src_start":0},{"artifact":1,"gen_end":588,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":404,"src_start":165},{"artifact":1,"gen_end":885,"gen_start":588,"node":15,"role":"declaration","source":0,"src_end":538,"src_start":406},{"artifact":1,"gen_end":1245,"gen_start":885,"node":16,"role":"declaration","source":0,"src_end":693,"src_start":540},{"artifact":1,"gen_end":1532,"gen_start":1245,"node":17,"role":"declaration","source":0,"src_end":1091,"src_start":695},{"artifact":1,"gen_end":1822,"gen_start":1532,"node":18,"role":"declaration","source":0,"src_end":1492,"src_start":1093},{"artifact":1,"gen_end":2105,"gen_start":1822,"node":19,"role":"declaration","source":0,"src_end":1617,"src_start":1494},{"artifact":1,"gen_end":3224,"gen_start":2105,"node":20,"role":"declaration","source":0,"src_end":1968,"src_start":1619},{"artifact":1,"gen_end":4043,"gen_start":3224,"node":21,"role":"declaration","source":0,"src_end":2270,"src_start":1970},{"artifact":1,"gen_end":4330,"gen_start":4043,"node":22,"role":"declaration","source":0,"src_end":2667,"src_start":2272},{"artifact":1,"gen_end":4550,"gen_start":4330,"node":23,"role":"declaration","source":0,"src_end":2819,"src_start":2669},{"artifact":1,"gen_end":5218,"gen_start":4550,"node":24,"role":"declaration","source":0,"src_end":2990,"src_start":2821},{"artifact":1,"gen_end":5653,"gen_start":5218,"node":25,"role":"declaration","source":0,"src_end":3136,"src_start":2992},{"artifact":1,"gen_end":5668,"gen_start":5653,"node":13,"role":"declaration","source":0,"src_end":3172,"src_start":0}],"module":"Policy","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Policy.lex.tex","sha256":"32d2ea99e908b81d5210299ee8e6148cc87e4ae72d9bef235cadf5cf69947ecf"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Recognizer.map.json b/examples/models/expected/build/maps/Models/Recognizer.map.json index 84dfffff8..6b5147119 100644 --- a/examples/models/expected/build/maps/Models/Recognizer.map.json +++ b/examples/models/expected/build/maps/Models/Recognizer.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Recognizer.lean"},{"id":1,"kind":"tex","path":"modules/Models/Recognizer.tex"}],"mappings":[{"artifact":0,"gen_end":377,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":0,"gen_end":2566,"gen_start":377,"node":1,"role":"declaration","source":0,"src_end":394,"src_start":169},{"artifact":0,"gen_end":3193,"gen_start":2566,"node":2,"role":"declaration","source":0,"src_end":609,"src_start":396},{"artifact":0,"gen_end":5967,"gen_start":3193,"node":3,"role":"declaration","source":0,"src_end":838,"src_start":611},{"artifact":0,"gen_end":6612,"gen_start":5967,"node":4,"role":"declaration","source":0,"src_end":1051,"src_start":840},{"artifact":0,"gen_end":7222,"gen_start":6612,"node":5,"role":"declaration","source":0,"src_end":1293,"src_start":1053},{"artifact":0,"gen_end":7442,"gen_start":7222,"node":6,"role":"declaration","source":0,"src_end":1462,"src_start":1295},{"artifact":0,"gen_end":7580,"gen_start":7442,"node":7,"role":"declaration","source":0,"src_end":1607,"src_start":1464},{"artifact":0,"gen_end":7722,"gen_start":7580,"node":8,"role":"declaration","source":0,"src_end":1778,"src_start":1609},{"artifact":0,"gen_end":10843,"gen_start":7722,"node":9,"role":"declaration","source":0,"src_end":2049,"src_start":1780},{"artifact":0,"gen_end":13967,"gen_start":10843,"node":10,"role":"declaration","source":0,"src_end":2323,"src_start":2051},{"artifact":0,"gen_end":14351,"gen_start":13967,"node":11,"role":"declaration","source":0,"src_end":2667,"src_start":2325},{"artifact":0,"gen_end":14531,"gen_start":14351,"node":12,"role":"declaration","source":0,"src_end":2872,"src_start":2669},{"artifact":0,"gen_end":18440,"gen_start":14531,"node":13,"role":"declaration","source":0,"src_end":3471,"src_start":2874},{"artifact":0,"gen_end":18790,"gen_start":18440,"node":14,"role":"declaration","source":0,"src_end":4240,"src_start":3473},{"artifact":0,"gen_end":19129,"gen_start":18790,"node":15,"role":"declaration","source":0,"src_end":5002,"src_start":4242},{"artifact":0,"gen_end":20581,"gen_start":19129,"node":16,"role":"declaration","source":0,"src_end":6574,"src_start":5004},{"artifact":0,"gen_end":20689,"gen_start":20581,"node":17,"role":"declaration","source":0,"src_end":6723,"src_start":6576},{"artifact":0,"gen_end":23771,"gen_start":20689,"node":18,"role":"declaration","source":0,"src_end":6963,"src_start":6725},{"artifact":0,"gen_end":24109,"gen_start":23771,"node":19,"role":"declaration","source":0,"src_end":7315,"src_start":6965},{"artifact":0,"gen_end":24655,"gen_start":24109,"node":20,"role":"declaration","source":0,"src_end":7800,"src_start":7317},{"artifact":0,"gen_end":24766,"gen_start":24655,"node":21,"role":"declaration","source":0,"src_end":7961,"src_start":7802},{"artifact":0,"gen_end":24880,"gen_start":24766,"node":22,"role":"declaration","source":0,"src_end":8086,"src_start":7963},{"artifact":0,"gen_end":25009,"gen_start":24880,"node":23,"role":"declaration","source":0,"src_end":8254,"src_start":8088},{"artifact":0,"gen_end":25032,"gen_start":25009,"node":0,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":24,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":1,"gen_end":857,"gen_start":134,"node":25,"role":"declaration","source":0,"src_end":394,"src_start":169},{"artifact":1,"gen_end":1552,"gen_start":857,"node":26,"role":"declaration","source":0,"src_end":609,"src_start":396},{"artifact":1,"gen_end":2277,"gen_start":1552,"node":27,"role":"declaration","source":0,"src_end":838,"src_start":611},{"artifact":1,"gen_end":2972,"gen_start":2277,"node":28,"role":"declaration","source":0,"src_end":1051,"src_start":840},{"artifact":1,"gen_end":3687,"gen_start":2972,"node":29,"role":"declaration","source":0,"src_end":1293,"src_start":1053},{"artifact":1,"gen_end":4306,"gen_start":3687,"node":30,"role":"declaration","source":0,"src_end":1462,"src_start":1295},{"artifact":1,"gen_end":4615,"gen_start":4306,"node":31,"role":"declaration","source":0,"src_end":1607,"src_start":1464},{"artifact":1,"gen_end":5004,"gen_start":4615,"node":32,"role":"declaration","source":0,"src_end":1778,"src_start":1609},{"artifact":1,"gen_end":5332,"gen_start":5004,"node":33,"role":"declaration","source":0,"src_end":2049,"src_start":1780},{"artifact":1,"gen_end":5663,"gen_start":5332,"node":34,"role":"declaration","source":0,"src_end":2323,"src_start":2051},{"artifact":1,"gen_end":6806,"gen_start":5663,"node":35,"role":"declaration","source":0,"src_end":2667,"src_start":2325},{"artifact":1,"gen_end":7096,"gen_start":6806,"node":36,"role":"declaration","source":0,"src_end":2872,"src_start":2669},{"artifact":1,"gen_end":12171,"gen_start":7096,"node":37,"role":"declaration","source":0,"src_end":3471,"src_start":2874},{"artifact":1,"gen_end":12456,"gen_start":12171,"node":38,"role":"declaration","source":0,"src_end":4240,"src_start":3473},{"artifact":1,"gen_end":12730,"gen_start":12456,"node":39,"role":"declaration","source":0,"src_end":5002,"src_start":4242},{"artifact":1,"gen_end":14328,"gen_start":12730,"node":40,"role":"declaration","source":0,"src_end":6574,"src_start":5004},{"artifact":1,"gen_end":14683,"gen_start":14328,"node":41,"role":"declaration","source":0,"src_end":6723,"src_start":6576},{"artifact":1,"gen_end":14990,"gen_start":14683,"node":42,"role":"declaration","source":0,"src_end":6963,"src_start":6725},{"artifact":1,"gen_end":15497,"gen_start":14990,"node":43,"role":"declaration","source":0,"src_end":7315,"src_start":6965},{"artifact":1,"gen_end":17615,"gen_start":15497,"node":44,"role":"declaration","source":0,"src_end":7800,"src_start":7317},{"artifact":1,"gen_end":18043,"gen_start":17615,"node":45,"role":"declaration","source":0,"src_end":7961,"src_start":7802},{"artifact":1,"gen_end":18477,"gen_start":18043,"node":46,"role":"declaration","source":0,"src_end":8086,"src_start":7963},{"artifact":1,"gen_end":18853,"gen_start":18477,"node":47,"role":"declaration","source":0,"src_end":8254,"src_start":8088},{"artifact":1,"gen_end":18868,"gen_start":18853,"node":24,"role":"declaration","source":0,"src_end":8290,"src_start":0}],"module":"Recognizer","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-latex-module"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Recognizer.lex.tex","sha256":"28bd37cb2876ff04da7a9efddf50a52d3019c64910aca2b806b4b6181e84b04b"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Recognizer.lean"},{"id":1,"kind":"tex","path":"modules/Models/Recognizer.tex"}],"mappings":[{"artifact":0,"gen_end":377,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":0,"gen_end":2566,"gen_start":377,"node":1,"role":"declaration","source":0,"src_end":394,"src_start":169},{"artifact":0,"gen_end":3193,"gen_start":2566,"node":2,"role":"declaration","source":0,"src_end":609,"src_start":396},{"artifact":0,"gen_end":5967,"gen_start":3193,"node":3,"role":"declaration","source":0,"src_end":838,"src_start":611},{"artifact":0,"gen_end":6612,"gen_start":5967,"node":4,"role":"declaration","source":0,"src_end":1051,"src_start":840},{"artifact":0,"gen_end":7222,"gen_start":6612,"node":5,"role":"declaration","source":0,"src_end":1293,"src_start":1053},{"artifact":0,"gen_end":7442,"gen_start":7222,"node":6,"role":"declaration","source":0,"src_end":1462,"src_start":1295},{"artifact":0,"gen_end":7580,"gen_start":7442,"node":7,"role":"declaration","source":0,"src_end":1607,"src_start":1464},{"artifact":0,"gen_end":7722,"gen_start":7580,"node":8,"role":"declaration","source":0,"src_end":1778,"src_start":1609},{"artifact":0,"gen_end":10843,"gen_start":7722,"node":9,"role":"declaration","source":0,"src_end":2049,"src_start":1780},{"artifact":0,"gen_end":13967,"gen_start":10843,"node":10,"role":"declaration","source":0,"src_end":2323,"src_start":2051},{"artifact":0,"gen_end":14351,"gen_start":13967,"node":11,"role":"declaration","source":0,"src_end":2667,"src_start":2325},{"artifact":0,"gen_end":14531,"gen_start":14351,"node":12,"role":"declaration","source":0,"src_end":2872,"src_start":2669},{"artifact":0,"gen_end":18440,"gen_start":14531,"node":13,"role":"declaration","source":0,"src_end":3471,"src_start":2874},{"artifact":0,"gen_end":18790,"gen_start":18440,"node":14,"role":"declaration","source":0,"src_end":4240,"src_start":3473},{"artifact":0,"gen_end":19129,"gen_start":18790,"node":15,"role":"declaration","source":0,"src_end":5002,"src_start":4242},{"artifact":0,"gen_end":20581,"gen_start":19129,"node":16,"role":"declaration","source":0,"src_end":6574,"src_start":5004},{"artifact":0,"gen_end":20689,"gen_start":20581,"node":17,"role":"declaration","source":0,"src_end":6723,"src_start":6576},{"artifact":0,"gen_end":23771,"gen_start":20689,"node":18,"role":"declaration","source":0,"src_end":6963,"src_start":6725},{"artifact":0,"gen_end":24109,"gen_start":23771,"node":19,"role":"declaration","source":0,"src_end":7315,"src_start":6965},{"artifact":0,"gen_end":24655,"gen_start":24109,"node":20,"role":"declaration","source":0,"src_end":7800,"src_start":7317},{"artifact":0,"gen_end":24766,"gen_start":24655,"node":21,"role":"declaration","source":0,"src_end":7961,"src_start":7802},{"artifact":0,"gen_end":24880,"gen_start":24766,"node":22,"role":"declaration","source":0,"src_end":8086,"src_start":7963},{"artifact":0,"gen_end":25009,"gen_start":24880,"node":23,"role":"declaration","source":0,"src_end":8254,"src_start":8088},{"artifact":0,"gen_end":25032,"gen_start":25009,"node":0,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":24,"role":"declaration","source":0,"src_end":8290,"src_start":0},{"artifact":1,"gen_end":857,"gen_start":134,"node":25,"role":"declaration","source":0,"src_end":394,"src_start":169},{"artifact":1,"gen_end":1552,"gen_start":857,"node":26,"role":"declaration","source":0,"src_end":609,"src_start":396},{"artifact":1,"gen_end":2277,"gen_start":1552,"node":27,"role":"declaration","source":0,"src_end":838,"src_start":611},{"artifact":1,"gen_end":2972,"gen_start":2277,"node":28,"role":"declaration","source":0,"src_end":1051,"src_start":840},{"artifact":1,"gen_end":3687,"gen_start":2972,"node":29,"role":"declaration","source":0,"src_end":1293,"src_start":1053},{"artifact":1,"gen_end":4306,"gen_start":3687,"node":30,"role":"declaration","source":0,"src_end":1462,"src_start":1295},{"artifact":1,"gen_end":4615,"gen_start":4306,"node":31,"role":"declaration","source":0,"src_end":1607,"src_start":1464},{"artifact":1,"gen_end":5004,"gen_start":4615,"node":32,"role":"declaration","source":0,"src_end":1778,"src_start":1609},{"artifact":1,"gen_end":5332,"gen_start":5004,"node":33,"role":"declaration","source":0,"src_end":2049,"src_start":1780},{"artifact":1,"gen_end":5663,"gen_start":5332,"node":34,"role":"declaration","source":0,"src_end":2323,"src_start":2051},{"artifact":1,"gen_end":6806,"gen_start":5663,"node":35,"role":"declaration","source":0,"src_end":2667,"src_start":2325},{"artifact":1,"gen_end":7096,"gen_start":6806,"node":36,"role":"declaration","source":0,"src_end":2872,"src_start":2669},{"artifact":1,"gen_end":12171,"gen_start":7096,"node":37,"role":"declaration","source":0,"src_end":3471,"src_start":2874},{"artifact":1,"gen_end":12456,"gen_start":12171,"node":38,"role":"declaration","source":0,"src_end":4240,"src_start":3473},{"artifact":1,"gen_end":12730,"gen_start":12456,"node":39,"role":"declaration","source":0,"src_end":5002,"src_start":4242},{"artifact":1,"gen_end":14328,"gen_start":12730,"node":40,"role":"declaration","source":0,"src_end":6574,"src_start":5004},{"artifact":1,"gen_end":14683,"gen_start":14328,"node":41,"role":"declaration","source":0,"src_end":6723,"src_start":6576},{"artifact":1,"gen_end":14990,"gen_start":14683,"node":42,"role":"declaration","source":0,"src_end":6963,"src_start":6725},{"artifact":1,"gen_end":15497,"gen_start":14990,"node":43,"role":"declaration","source":0,"src_end":7315,"src_start":6965},{"artifact":1,"gen_end":17615,"gen_start":15497,"node":44,"role":"declaration","source":0,"src_end":7800,"src_start":7317},{"artifact":1,"gen_end":18043,"gen_start":17615,"node":45,"role":"declaration","source":0,"src_end":7961,"src_start":7802},{"artifact":1,"gen_end":18477,"gen_start":18043,"node":46,"role":"declaration","source":0,"src_end":8086,"src_start":7963},{"artifact":1,"gen_end":18853,"gen_start":18477,"node":47,"role":"declaration","source":0,"src_end":8254,"src_start":8088},{"artifact":1,"gen_end":18868,"gen_start":18853,"node":24,"role":"declaration","source":0,"src_end":8290,"src_start":0}],"module":"Recognizer","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-latex-module"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Recognizer.lex.tex","sha256":"28bd37cb2876ff04da7a9efddf50a52d3019c64910aca2b806b4b6181e84b04b"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Session.map.json b/examples/models/expected/build/maps/Models/Session.map.json index 4f6257bfa..d96dd6fcd 100644 --- a/examples/models/expected/build/maps/Models/Session.map.json +++ b/examples/models/expected/build/maps/Models/Session.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Session.lean"},{"id":1,"kind":"tex","path":"modules/Models/Session.tex"}],"mappings":[{"artifact":0,"gen_end":305,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":0,"gen_end":363,"gen_start":305,"node":1,"role":"declaration","source":0,"src_end":273,"src_start":142},{"artifact":0,"gen_end":462,"gen_start":363,"node":2,"role":"declaration","source":0,"src_end":390,"src_start":275},{"artifact":0,"gen_end":564,"gen_start":462,"node":3,"role":"declaration","source":0,"src_end":533,"src_start":392},{"artifact":0,"gen_end":3672,"gen_start":564,"node":4,"role":"declaration","source":0,"src_end":797,"src_start":535},{"artifact":0,"gen_end":3763,"gen_start":3672,"node":5,"role":"declaration","source":0,"src_end":916,"src_start":799},{"artifact":0,"gen_end":3857,"gen_start":3763,"node":6,"role":"declaration","source":0,"src_end":1061,"src_start":918},{"artifact":0,"gen_end":6923,"gen_start":3857,"node":7,"role":"declaration","source":0,"src_end":1288,"src_start":1063},{"artifact":0,"gen_end":7098,"gen_start":6923,"node":8,"role":"declaration","source":0,"src_end":1496,"src_start":1290},{"artifact":0,"gen_end":7445,"gen_start":7098,"node":9,"role":"declaration","source":0,"src_end":1950,"src_start":1498},{"artifact":0,"gen_end":7936,"gen_start":7445,"node":10,"role":"declaration","source":0,"src_end":2399,"src_start":1952},{"artifact":0,"gen_end":8015,"gen_start":7936,"node":11,"role":"declaration","source":0,"src_end":2518,"src_start":2401},{"artifact":0,"gen_end":11146,"gen_start":8015,"node":12,"role":"declaration","source":0,"src_end":2821,"src_start":2520},{"artifact":0,"gen_end":14340,"gen_start":11146,"node":13,"role":"declaration","source":0,"src_end":3184,"src_start":2823},{"artifact":0,"gen_end":14941,"gen_start":14340,"node":14,"role":"declaration","source":0,"src_end":3501,"src_start":3186},{"artifact":0,"gen_end":15219,"gen_start":14941,"node":15,"role":"declaration","source":0,"src_end":3650,"src_start":3503},{"artifact":0,"gen_end":15239,"gen_start":15219,"node":0,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":16,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":1,"gen_end":303,"gen_start":134,"node":17,"role":"declaration","source":0,"src_end":273,"src_start":142},{"artifact":1,"gen_end":572,"gen_start":303,"node":18,"role":"declaration","source":0,"src_end":390,"src_start":275},{"artifact":1,"gen_end":920,"gen_start":572,"node":19,"role":"declaration","source":0,"src_end":533,"src_start":392},{"artifact":1,"gen_end":1235,"gen_start":920,"node":20,"role":"declaration","source":0,"src_end":797,"src_start":535},{"artifact":1,"gen_end":1497,"gen_start":1235,"node":21,"role":"declaration","source":0,"src_end":916,"src_start":799},{"artifact":1,"gen_end":1838,"gen_start":1497,"node":22,"role":"declaration","source":0,"src_end":1061,"src_start":918},{"artifact":1,"gen_end":2117,"gen_start":1838,"node":23,"role":"declaration","source":0,"src_end":1288,"src_start":1063},{"artifact":1,"gen_end":2463,"gen_start":2117,"node":24,"role":"declaration","source":0,"src_end":1496,"src_start":1290},{"artifact":1,"gen_end":3721,"gen_start":2463,"node":25,"role":"declaration","source":0,"src_end":1950,"src_start":1498},{"artifact":1,"gen_end":4778,"gen_start":3721,"node":26,"role":"declaration","source":0,"src_end":2399,"src_start":1952},{"artifact":1,"gen_end":4964,"gen_start":4778,"node":27,"role":"declaration","source":0,"src_end":2518,"src_start":2401},{"artifact":1,"gen_end":5308,"gen_start":4964,"node":28,"role":"declaration","source":0,"src_end":2821,"src_start":2520},{"artifact":1,"gen_end":5704,"gen_start":5308,"node":29,"role":"declaration","source":0,"src_end":3184,"src_start":2823},{"artifact":1,"gen_end":7335,"gen_start":5704,"node":30,"role":"declaration","source":0,"src_end":3501,"src_start":3186},{"artifact":1,"gen_end":7919,"gen_start":7335,"node":31,"role":"declaration","source":0,"src_end":3650,"src_start":3503},{"artifact":1,"gen_end":7934,"gen_start":7919,"node":16,"role":"declaration","source":0,"src_end":3686,"src_start":0}],"module":"Session","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-latex-module"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Session.lex.tex","sha256":"0077c43c5251814a8329dc387538b9d0aafb0780238f61ce60bb245e9a15bbb1"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Session.lean"},{"id":1,"kind":"tex","path":"modules/Models/Session.tex"}],"mappings":[{"artifact":0,"gen_end":305,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":0,"gen_end":363,"gen_start":305,"node":1,"role":"declaration","source":0,"src_end":273,"src_start":142},{"artifact":0,"gen_end":462,"gen_start":363,"node":2,"role":"declaration","source":0,"src_end":390,"src_start":275},{"artifact":0,"gen_end":564,"gen_start":462,"node":3,"role":"declaration","source":0,"src_end":533,"src_start":392},{"artifact":0,"gen_end":3672,"gen_start":564,"node":4,"role":"declaration","source":0,"src_end":797,"src_start":535},{"artifact":0,"gen_end":3763,"gen_start":3672,"node":5,"role":"declaration","source":0,"src_end":916,"src_start":799},{"artifact":0,"gen_end":3857,"gen_start":3763,"node":6,"role":"declaration","source":0,"src_end":1061,"src_start":918},{"artifact":0,"gen_end":6923,"gen_start":3857,"node":7,"role":"declaration","source":0,"src_end":1288,"src_start":1063},{"artifact":0,"gen_end":7098,"gen_start":6923,"node":8,"role":"declaration","source":0,"src_end":1496,"src_start":1290},{"artifact":0,"gen_end":7445,"gen_start":7098,"node":9,"role":"declaration","source":0,"src_end":1950,"src_start":1498},{"artifact":0,"gen_end":7936,"gen_start":7445,"node":10,"role":"declaration","source":0,"src_end":2399,"src_start":1952},{"artifact":0,"gen_end":8015,"gen_start":7936,"node":11,"role":"declaration","source":0,"src_end":2518,"src_start":2401},{"artifact":0,"gen_end":11146,"gen_start":8015,"node":12,"role":"declaration","source":0,"src_end":2821,"src_start":2520},{"artifact":0,"gen_end":14340,"gen_start":11146,"node":13,"role":"declaration","source":0,"src_end":3184,"src_start":2823},{"artifact":0,"gen_end":14941,"gen_start":14340,"node":14,"role":"declaration","source":0,"src_end":3501,"src_start":3186},{"artifact":0,"gen_end":15219,"gen_start":14941,"node":15,"role":"declaration","source":0,"src_end":3650,"src_start":3503},{"artifact":0,"gen_end":15239,"gen_start":15219,"node":0,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":16,"role":"declaration","source":0,"src_end":3686,"src_start":0},{"artifact":1,"gen_end":303,"gen_start":134,"node":17,"role":"declaration","source":0,"src_end":273,"src_start":142},{"artifact":1,"gen_end":572,"gen_start":303,"node":18,"role":"declaration","source":0,"src_end":390,"src_start":275},{"artifact":1,"gen_end":920,"gen_start":572,"node":19,"role":"declaration","source":0,"src_end":533,"src_start":392},{"artifact":1,"gen_end":1235,"gen_start":920,"node":20,"role":"declaration","source":0,"src_end":797,"src_start":535},{"artifact":1,"gen_end":1497,"gen_start":1235,"node":21,"role":"declaration","source":0,"src_end":916,"src_start":799},{"artifact":1,"gen_end":1838,"gen_start":1497,"node":22,"role":"declaration","source":0,"src_end":1061,"src_start":918},{"artifact":1,"gen_end":2117,"gen_start":1838,"node":23,"role":"declaration","source":0,"src_end":1288,"src_start":1063},{"artifact":1,"gen_end":2463,"gen_start":2117,"node":24,"role":"declaration","source":0,"src_end":1496,"src_start":1290},{"artifact":1,"gen_end":3721,"gen_start":2463,"node":25,"role":"declaration","source":0,"src_end":1950,"src_start":1498},{"artifact":1,"gen_end":4778,"gen_start":3721,"node":26,"role":"declaration","source":0,"src_end":2399,"src_start":1952},{"artifact":1,"gen_end":4964,"gen_start":4778,"node":27,"role":"declaration","source":0,"src_end":2518,"src_start":2401},{"artifact":1,"gen_end":5308,"gen_start":4964,"node":28,"role":"declaration","source":0,"src_end":2821,"src_start":2520},{"artifact":1,"gen_end":5704,"gen_start":5308,"node":29,"role":"declaration","source":0,"src_end":3184,"src_start":2823},{"artifact":1,"gen_end":7335,"gen_start":5704,"node":30,"role":"declaration","source":0,"src_end":3501,"src_start":3186},{"artifact":1,"gen_end":7919,"gen_start":7335,"node":31,"role":"declaration","source":0,"src_end":3650,"src_start":3503},{"artifact":1,"gen_end":7934,"gen_start":7919,"node":16,"role":"declaration","source":0,"src_end":3686,"src_start":0}],"module":"Session","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-latex-module"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Session.lex.tex","sha256":"0077c43c5251814a8329dc387538b9d0aafb0780238f61ce60bb245e9a15bbb1"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/build/maps/Models/Triage.map.json b/examples/models/expected/build/maps/Models/Triage.map.json index 9158f8c00..3d7301678 100644 --- a/examples/models/expected/build/maps/Models/Triage.map.json +++ b/examples/models/expected/build/maps/Models/Triage.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Triage.lean"},{"id":1,"kind":"tex","path":"modules/Models/Triage.tex"}],"mappings":[{"artifact":0,"gen_end":311,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":0,"gen_end":404,"gen_start":311,"node":1,"role":"declaration","source":0,"src_end":460,"src_start":140},{"artifact":0,"gen_end":471,"gen_start":404,"node":2,"role":"declaration","source":0,"src_end":651,"src_start":462},{"artifact":0,"gen_end":1246,"gen_start":471,"node":3,"role":"declaration","source":0,"src_end":1488,"src_start":653},{"artifact":0,"gen_end":1554,"gen_start":1246,"node":4,"role":"declaration","source":0,"src_end":1874,"src_start":1490},{"artifact":0,"gen_end":1867,"gen_start":1554,"node":5,"role":"declaration","source":0,"src_end":2265,"src_start":1876},{"artifact":0,"gen_end":2021,"gen_start":1867,"node":6,"role":"declaration","source":0,"src_end":2465,"src_start":2267},{"artifact":0,"gen_end":2173,"gen_start":2021,"node":7,"role":"declaration","source":0,"src_end":2663,"src_start":2467},{"artifact":0,"gen_end":2293,"gen_start":2173,"node":8,"role":"declaration","source":0,"src_end":2803,"src_start":2665},{"artifact":0,"gen_end":2398,"gen_start":2293,"node":9,"role":"declaration","source":0,"src_end":2959,"src_start":2805},{"artifact":0,"gen_end":2743,"gen_start":2398,"node":10,"role":"declaration","source":0,"src_end":3646,"src_start":2961},{"artifact":0,"gen_end":2908,"gen_start":2743,"node":11,"role":"declaration","source":0,"src_end":3830,"src_start":3648},{"artifact":0,"gen_end":3562,"gen_start":2908,"node":12,"role":"declaration","source":0,"src_end":4057,"src_start":3832},{"artifact":0,"gen_end":3914,"gen_start":3562,"node":13,"role":"declaration","source":0,"src_end":4270,"src_start":4059},{"artifact":0,"gen_end":4093,"gen_start":3914,"node":14,"role":"declaration","source":0,"src_end":4559,"src_start":4272},{"artifact":0,"gen_end":4392,"gen_start":4093,"node":15,"role":"declaration","source":0,"src_end":5252,"src_start":4561},{"artifact":0,"gen_end":6504,"gen_start":4392,"node":16,"role":"declaration","source":0,"src_end":5674,"src_start":5254},{"artifact":0,"gen_end":6845,"gen_start":6504,"node":17,"role":"declaration","source":0,"src_end":6376,"src_start":5676},{"artifact":0,"gen_end":7026,"gen_start":6845,"node":18,"role":"declaration","source":0,"src_end":6563,"src_start":6378},{"artifact":0,"gen_end":7160,"gen_start":7026,"node":19,"role":"declaration","source":0,"src_end":6730,"src_start":6565},{"artifact":0,"gen_end":7179,"gen_start":7160,"node":0,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":20,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":1,"gen_end":626,"gen_start":134,"node":21,"role":"declaration","source":0,"src_end":460,"src_start":140},{"artifact":1,"gen_end":867,"gen_start":626,"node":22,"role":"declaration","source":0,"src_end":651,"src_start":462},{"artifact":1,"gen_end":1889,"gen_start":867,"node":23,"role":"declaration","source":0,"src_end":1488,"src_start":653},{"artifact":1,"gen_end":2444,"gen_start":1889,"node":24,"role":"declaration","source":0,"src_end":1874,"src_start":1490},{"artifact":1,"gen_end":3004,"gen_start":2444,"node":25,"role":"declaration","source":0,"src_end":2265,"src_start":1876},{"artifact":1,"gen_end":3405,"gen_start":3004,"node":26,"role":"declaration","source":0,"src_end":2465,"src_start":2267},{"artifact":1,"gen_end":3804,"gen_start":3405,"node":27,"role":"declaration","source":0,"src_end":2663,"src_start":2467},{"artifact":1,"gen_end":4095,"gen_start":3804,"node":28,"role":"declaration","source":0,"src_end":2803,"src_start":2665},{"artifact":1,"gen_end":4447,"gen_start":4095,"node":29,"role":"declaration","source":0,"src_end":2959,"src_start":2805},{"artifact":1,"gen_end":4751,"gen_start":4447,"node":30,"role":"declaration","source":0,"src_end":3646,"src_start":2961},{"artifact":1,"gen_end":5087,"gen_start":4751,"node":31,"role":"declaration","source":0,"src_end":3830,"src_start":3648},{"artifact":1,"gen_end":5810,"gen_start":5087,"node":32,"role":"declaration","source":0,"src_end":4057,"src_start":3832},{"artifact":1,"gen_end":6503,"gen_start":5810,"node":33,"role":"declaration","source":0,"src_end":4270,"src_start":4059},{"artifact":1,"gen_end":7268,"gen_start":6503,"node":34,"role":"declaration","source":0,"src_end":4559,"src_start":4272},{"artifact":1,"gen_end":7549,"gen_start":7268,"node":35,"role":"declaration","source":0,"src_end":5252,"src_start":4561},{"artifact":1,"gen_end":10368,"gen_start":7549,"node":36,"role":"declaration","source":0,"src_end":5674,"src_start":5254},{"artifact":1,"gen_end":10678,"gen_start":10368,"node":37,"role":"declaration","source":0,"src_end":6376,"src_start":5676},{"artifact":1,"gen_end":11359,"gen_start":10678,"node":38,"role":"declaration","source":0,"src_end":6563,"src_start":6378},{"artifact":1,"gen_end":11800,"gen_start":11359,"node":39,"role":"declaration","source":0,"src_end":6730,"src_start":6565},{"artifact":1,"gen_end":11815,"gen_start":11800,"node":20,"role":"declaration","source":0,"src_end":6766,"src_start":0}],"module":"Triage","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-latex-module"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"}],"semantic_id":"49cf062e918bdc2f8a44a66473c4435ee310d33b78d7093624f025547ab95bfd","source_id":"029a1a5ebafd24dc317957624d7e5417c3a563331be1ac2c56d796c47a51d75f","sources":[{"id":0,"kind":"file","path":"src/Triage.lex.tex","sha256":"61ce4693fcb18df340d1f0f9a9a0d29a73912cc4075bd20dcbda09508373808b"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Models/Triage.lean"},{"id":1,"kind":"tex","path":"modules/Models/Triage.tex"}],"mappings":[{"artifact":0,"gen_end":311,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":0,"gen_end":404,"gen_start":311,"node":1,"role":"declaration","source":0,"src_end":460,"src_start":140},{"artifact":0,"gen_end":471,"gen_start":404,"node":2,"role":"declaration","source":0,"src_end":651,"src_start":462},{"artifact":0,"gen_end":1246,"gen_start":471,"node":3,"role":"declaration","source":0,"src_end":1488,"src_start":653},{"artifact":0,"gen_end":1554,"gen_start":1246,"node":4,"role":"declaration","source":0,"src_end":1874,"src_start":1490},{"artifact":0,"gen_end":1867,"gen_start":1554,"node":5,"role":"declaration","source":0,"src_end":2265,"src_start":1876},{"artifact":0,"gen_end":2021,"gen_start":1867,"node":6,"role":"declaration","source":0,"src_end":2465,"src_start":2267},{"artifact":0,"gen_end":2173,"gen_start":2021,"node":7,"role":"declaration","source":0,"src_end":2663,"src_start":2467},{"artifact":0,"gen_end":2293,"gen_start":2173,"node":8,"role":"declaration","source":0,"src_end":2803,"src_start":2665},{"artifact":0,"gen_end":2398,"gen_start":2293,"node":9,"role":"declaration","source":0,"src_end":2959,"src_start":2805},{"artifact":0,"gen_end":2743,"gen_start":2398,"node":10,"role":"declaration","source":0,"src_end":3646,"src_start":2961},{"artifact":0,"gen_end":2908,"gen_start":2743,"node":11,"role":"declaration","source":0,"src_end":3830,"src_start":3648},{"artifact":0,"gen_end":3562,"gen_start":2908,"node":12,"role":"declaration","source":0,"src_end":4057,"src_start":3832},{"artifact":0,"gen_end":3914,"gen_start":3562,"node":13,"role":"declaration","source":0,"src_end":4270,"src_start":4059},{"artifact":0,"gen_end":4093,"gen_start":3914,"node":14,"role":"declaration","source":0,"src_end":4559,"src_start":4272},{"artifact":0,"gen_end":4392,"gen_start":4093,"node":15,"role":"declaration","source":0,"src_end":5252,"src_start":4561},{"artifact":0,"gen_end":6504,"gen_start":4392,"node":16,"role":"declaration","source":0,"src_end":5674,"src_start":5254},{"artifact":0,"gen_end":6845,"gen_start":6504,"node":17,"role":"declaration","source":0,"src_end":6376,"src_start":5676},{"artifact":0,"gen_end":7026,"gen_start":6845,"node":18,"role":"declaration","source":0,"src_end":6563,"src_start":6378},{"artifact":0,"gen_end":7160,"gen_start":7026,"node":19,"role":"declaration","source":0,"src_end":6730,"src_start":6565},{"artifact":0,"gen_end":7179,"gen_start":7160,"node":0,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":20,"role":"declaration","source":0,"src_end":6766,"src_start":0},{"artifact":1,"gen_end":626,"gen_start":134,"node":21,"role":"declaration","source":0,"src_end":460,"src_start":140},{"artifact":1,"gen_end":867,"gen_start":626,"node":22,"role":"declaration","source":0,"src_end":651,"src_start":462},{"artifact":1,"gen_end":1889,"gen_start":867,"node":23,"role":"declaration","source":0,"src_end":1488,"src_start":653},{"artifact":1,"gen_end":2444,"gen_start":1889,"node":24,"role":"declaration","source":0,"src_end":1874,"src_start":1490},{"artifact":1,"gen_end":3004,"gen_start":2444,"node":25,"role":"declaration","source":0,"src_end":2265,"src_start":1876},{"artifact":1,"gen_end":3405,"gen_start":3004,"node":26,"role":"declaration","source":0,"src_end":2465,"src_start":2267},{"artifact":1,"gen_end":3804,"gen_start":3405,"node":27,"role":"declaration","source":0,"src_end":2663,"src_start":2467},{"artifact":1,"gen_end":4095,"gen_start":3804,"node":28,"role":"declaration","source":0,"src_end":2803,"src_start":2665},{"artifact":1,"gen_end":4447,"gen_start":4095,"node":29,"role":"declaration","source":0,"src_end":2959,"src_start":2805},{"artifact":1,"gen_end":4751,"gen_start":4447,"node":30,"role":"declaration","source":0,"src_end":3646,"src_start":2961},{"artifact":1,"gen_end":5087,"gen_start":4751,"node":31,"role":"declaration","source":0,"src_end":3830,"src_start":3648},{"artifact":1,"gen_end":5810,"gen_start":5087,"node":32,"role":"declaration","source":0,"src_end":4057,"src_start":3832},{"artifact":1,"gen_end":6503,"gen_start":5810,"node":33,"role":"declaration","source":0,"src_end":4270,"src_start":4059},{"artifact":1,"gen_end":7268,"gen_start":6503,"node":34,"role":"declaration","source":0,"src_end":4559,"src_start":4272},{"artifact":1,"gen_end":7549,"gen_start":7268,"node":35,"role":"declaration","source":0,"src_end":5252,"src_start":4561},{"artifact":1,"gen_end":10368,"gen_start":7549,"node":36,"role":"declaration","source":0,"src_end":5674,"src_start":5254},{"artifact":1,"gen_end":10678,"gen_start":10368,"node":37,"role":"declaration","source":0,"src_end":6376,"src_start":5676},{"artifact":1,"gen_end":11359,"gen_start":10678,"node":38,"role":"declaration","source":0,"src_end":6563,"src_start":6378},{"artifact":1,"gen_end":11800,"gen_start":11359,"node":39,"role":"declaration","source":0,"src_end":6730,"src_start":6565},{"artifact":1,"gen_end":11815,"gen_start":11800,"node":20,"role":"declaration","source":0,"src_end":6766,"src_start":0}],"module":"Triage","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-latex-module"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"}],"semantic_id":"91b57d30cfd6f60128d6c72e374148ef2e79e45a626e878a7c7551c9a29b1534","source_id":"a2b28f35f0ba5d1a28d3832af59389874c0d5e4006af1c81f108c4bed5e405aa","sources":[{"id":0,"kind":"file","path":"src/Triage.lex.tex","sha256":"61ce4693fcb18df340d1f0f9a9a0d29a73912cc4075bd20dcbda09508373808b"}],"spec":"lexlean/source-map/1"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Collections.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.process.json similarity index 97% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.process.json index 70da36a00..cd1d0d0a5 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.process.json similarity index 95% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.process.json index 8b29455bb..2d58d2bf8 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.process.json similarity index 90% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.process.json index d20975b12..9832e8650 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.process.json similarity index 98% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.process.json index 47effcc90..6bfb8bc44 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.process.json similarity index 95% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.process.json index f37d5dde9..1cbebed5d 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Flows","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Flows.BothCapped' does not depend on any axioms\n'Models.Flows.BranchContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.BranchContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.BranchModel' does not depend on any axioms\n'Models.Flows.BranchModel.initial' does not depend on any axioms\n'Models.Flows.ChainContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.ChainContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.ChainModel' does not depend on any axioms\n'Models.Flows.ChainModel.initial' does not depend on any axioms\n'Models.Flows.ClampBoth' does not depend on any axioms\n'Models.Flows.ClampBoth.initial' does not depend on any axioms\n'Models.Flows.ClampGuess' does not depend on any axioms\n'Models.Flows.ClampGuess.initial' does not depend on any axioms\n'Models.Flows.ClampOrTally' does not depend on any axioms\n'Models.Flows.ClampOrTally.initial' does not depend on any axioms\n'Models.Flows.ClampTally' does not depend on any axioms\n'Models.Flows.ClampTally.initial' does not depend on any axioms\n'Models.Flows.Drain' does not depend on any axioms\n'Models.Flows.Drain.initial' does not depend on any axioms\n'Models.Flows.DrainChainModel' does not depend on any axioms\n'Models.Flows.DrainChainModel.initial' does not depend on any axioms\n'Models.Flows.DrainModel' does not depend on any axioms\n'Models.Flows.DrainModel.initial' does not depend on any axioms\n'Models.Flows.Few' does not depend on any axioms\n'Models.Flows.FlowContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.FlowModel' does not depend on any axioms\n'Models.Flows.FlowModel.initial' does not depend on any axioms\n'Models.Flows.GuessOvershoot' does not depend on any axioms\n'Models.Flows.GuessTwice' does not depend on any axioms\n'Models.Flows.OvershootPairModel' does not depend on any axioms\n'Models.Flows.PairClampContract.invariant_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Flows.PairClampModel' does not depend on any axioms\n'Models.Flows.PairClampModel.initial' does not depend on any axioms\n'Models.Flows.PairGuessContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.PairGuessModel' does not depend on any axioms\n'Models.Flows.RawChainContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.RawChainModel' does not depend on any axioms\n'Models.Flows.RawChainModel.initial' does not depend on any axioms\n'Models.Flows.SpillStream' does not depend on any axioms\n'Models.Flows.SpillStreamContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.SpillStreamModel' does not depend on any axioms\n'Models.Flows.SpillTally' does not depend on any axioms\n'Models.Flows.SpillTally.initial' does not depend on any axioms\n'Models.Flows.TallyDrain' does not depend on any axioms\n'Models.Flows.TallyDrain.initial' does not depend on any axioms\n'Models.Flows.TallySpillRaw' does not depend on any axioms\n'Models.Flows.TallySpillRaw.initial' does not depend on any axioms\n'Models.Flows.TwinCapped' does not depend on any axioms\n'Models.Flows.TwinContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.TwinContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.TwinModel' does not depend on any axioms\n'Models.Flows.TwinModel.initial' does not depend on any axioms\n'Models.Flows.TwinSmall' does not depend on any axioms\n'Models.Flows.bothCappedCheck' does not depend on any axioms\n'Models.Flows.both_capped_check_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Flows.both_entry_left' depends on axioms: [propext, Quot.sound]\n'Models.Flows.both_entry_right' depends on axioms: [propext, Quot.sound]\n'Models.Flows.branch_entry_else' does not depend on any axioms\n'Models.Flows.branch_entry_then' does not depend on any axioms\n'Models.Flows.chain_entry_invariant' does not depend on any axioms\n'Models.Flows.chain_entry_precondition' does not depend on any axioms\n'Models.Flows.fewCheck' does not depend on any axioms\n'Models.Flows.few_check_sound' depends on axioms: [propext]\n'Models.Flows.flow_capped_sound' depends on axioms: [propext]\n'Models.Flows.flow_entry' does not depend on any axioms\n'Models.Flows.pair_entry_left' does not depend on any axioms\n'Models.Flows.pair_entry_right' does not depend on any axioms\n'Models.Flows.pair_within_sound' depends on axioms: [propext]\n'Models.Flows.spill_tally' does not depend on any axioms\n'Models.Flows.twinCappedCheck' does not depend on any axioms\n'Models.Flows.twinSmallCheck' does not depend on any axioms\n'Models.Flows.twin_capped_check_sound' depends on axioms: [propext]\n'Models.Flows.twin_entry_left' does not depend on any axioms\n'Models.Flows.twin_entry_right' does not depend on any axioms\n'Models.Flows.twin_small_check_sound' depends on axioms: [propext]\n","stdout_sha256":"090ddb641a708c3d8e10daed419a524c1203ac41b5b8ae709a5dd78aea4fbf2b","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Flows","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Flows.BothCapped' does not depend on any axioms\n'Models.Flows.BranchContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.BranchContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.BranchModel' does not depend on any axioms\n'Models.Flows.BranchModel.initial' does not depend on any axioms\n'Models.Flows.ChainContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.ChainContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.ChainModel' does not depend on any axioms\n'Models.Flows.ChainModel.initial' does not depend on any axioms\n'Models.Flows.ClampBoth' does not depend on any axioms\n'Models.Flows.ClampBoth.initial' does not depend on any axioms\n'Models.Flows.ClampGuess' does not depend on any axioms\n'Models.Flows.ClampGuess.initial' does not depend on any axioms\n'Models.Flows.ClampOrTally' does not depend on any axioms\n'Models.Flows.ClampOrTally.initial' does not depend on any axioms\n'Models.Flows.ClampTally' does not depend on any axioms\n'Models.Flows.ClampTally.initial' does not depend on any axioms\n'Models.Flows.Drain' does not depend on any axioms\n'Models.Flows.Drain.initial' does not depend on any axioms\n'Models.Flows.DrainChainModel' does not depend on any axioms\n'Models.Flows.DrainChainModel.initial' does not depend on any axioms\n'Models.Flows.DrainModel' does not depend on any axioms\n'Models.Flows.DrainModel.initial' does not depend on any axioms\n'Models.Flows.Few' does not depend on any axioms\n'Models.Flows.FlowContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.FlowModel' does not depend on any axioms\n'Models.Flows.FlowModel.initial' does not depend on any axioms\n'Models.Flows.GuessOvershoot' does not depend on any axioms\n'Models.Flows.GuessTwice' does not depend on any axioms\n'Models.Flows.OvershootPairModel' does not depend on any axioms\n'Models.Flows.PairClampContract.invariant_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Flows.PairClampModel' does not depend on any axioms\n'Models.Flows.PairClampModel.initial' does not depend on any axioms\n'Models.Flows.PairGuessContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.PairGuessModel' does not depend on any axioms\n'Models.Flows.RawChainContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.RawChainModel' does not depend on any axioms\n'Models.Flows.RawChainModel.initial' does not depend on any axioms\n'Models.Flows.SpillStream' does not depend on any axioms\n'Models.Flows.SpillStreamContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.SpillStreamModel' does not depend on any axioms\n'Models.Flows.SpillTally' does not depend on any axioms\n'Models.Flows.SpillTally.initial' does not depend on any axioms\n'Models.Flows.TallyDrain' does not depend on any axioms\n'Models.Flows.TallyDrain.initial' does not depend on any axioms\n'Models.Flows.TallySpillRaw' does not depend on any axioms\n'Models.Flows.TallySpillRaw.initial' does not depend on any axioms\n'Models.Flows.TwinCapped' does not depend on any axioms\n'Models.Flows.TwinContract.invariant_sound' depends on axioms: [propext]\n'Models.Flows.TwinContract.precondition_sound' depends on axioms: [propext]\n'Models.Flows.TwinModel' does not depend on any axioms\n'Models.Flows.TwinModel.initial' does not depend on any axioms\n'Models.Flows.TwinSmall' does not depend on any axioms\n'Models.Flows.bothCappedCheck' does not depend on any axioms\n'Models.Flows.both_capped_check_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Flows.both_entry_left' depends on axioms: [propext, Quot.sound]\n'Models.Flows.both_entry_right' depends on axioms: [propext, Quot.sound]\n'Models.Flows.branch_entry_else' does not depend on any axioms\n'Models.Flows.branch_entry_then' does not depend on any axioms\n'Models.Flows.chain_entry_invariant' does not depend on any axioms\n'Models.Flows.chain_entry_precondition' does not depend on any axioms\n'Models.Flows.fewCheck' does not depend on any axioms\n'Models.Flows.few_check_sound' depends on axioms: [propext]\n'Models.Flows.flow_capped_sound' depends on axioms: [propext]\n'Models.Flows.flow_entry' does not depend on any axioms\n'Models.Flows.pair_entry_left' does not depend on any axioms\n'Models.Flows.pair_entry_right' does not depend on any axioms\n'Models.Flows.pair_within_sound' depends on axioms: [propext]\n'Models.Flows.spill_tally' does not depend on any axioms\n'Models.Flows.twinCappedCheck' does not depend on any axioms\n'Models.Flows.twinSmallCheck' does not depend on any axioms\n'Models.Flows.twin_capped_check_sound' depends on axioms: [propext]\n'Models.Flows.twin_entry_left' does not depend on any axioms\n'Models.Flows.twin_entry_right' does not depend on any axioms\n'Models.Flows.twin_small_check_sound' depends on axioms: [propext]\n","stdout_sha256":"090ddb641a708c3d8e10daed419a524c1203ac41b5b8ae709a5dd78aea4fbf2b","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.process.json similarity index 67% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.process.json index 9f11d8307..e66b00c7f 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Glyphs","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Glyphs.Glyph' does not depend on any axioms\n'Models.Glyphs.digitOf' does not depend on any axioms\n'Models.Glyphs.encode' does not depend on any axioms\n'Models.Glyphs.encode_width' does not depend on any axioms\n'Models.Glyphs.isEight' does not depend on any axioms\n'Models.Glyphs.segmentCount' does not depend on any axioms\n","stdout_sha256":"1764c5768cb6db2798341b7ddfaf8b768b57d2bb29d42349f16699721cb3527c","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Glyphs","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Glyphs.Glyph' does not depend on any axioms\n'Models.Glyphs.digitOf' does not depend on any axioms\n'Models.Glyphs.encode' does not depend on any axioms\n'Models.Glyphs.encode_width' does not depend on any axioms\n'Models.Glyphs.isEight' does not depend on any axioms\n'Models.Glyphs.segmentCount' does not depend on any axioms\n","stdout_sha256":"1764c5768cb6db2798341b7ddfaf8b768b57d2bb29d42349f16699721cb3527c","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.process.json similarity index 95% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.process.json index 61b9e609e..515515212 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Ledger","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Ledger.Below' does not depend on any axioms\n'Models.Ledger.CapContract.invariant_complete' depends on axioms: [propext]\n'Models.Ledger.CapContract.invariant_sound' depends on axioms: [propext]\n'Models.Ledger.CapContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.Capped' does not depend on any axioms\n'Models.Ledger.Clamp' does not depend on any axioms\n'Models.Ledger.Clamp.initial' does not depend on any axioms\n'Models.Ledger.ClampEvidence.clamp_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.ClampEvidence.clamp_initial' does not depend on any axioms\n'Models.Ledger.ClampEvidence.clamp_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.ClampEvidence.clamp_reference' depends on axioms: [propext]\n'Models.Ledger.ClampModel' does not depend on any axioms\n'Models.Ledger.ClampModel.initial' does not depend on any axioms\n'Models.Ledger.FreeContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.FreeEvidence.tally_free_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.FreeEvidence.tally_free_reference' depends on axioms: [propext]\n'Models.Ledger.FreeModel' does not depend on any axioms\n'Models.Ledger.FreeModel.initial' does not depend on any axioms\n'Models.Ledger.Grows' does not depend on any axioms\n'Models.Ledger.Guess' does not depend on any axioms\n'Models.Ledger.GuessContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.GuessContract.precondition_complete' depends on axioms: [propext]\n'Models.Ledger.GuessContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.GuessEquivalence.guess_reference' depends on axioms: [propext]\n'Models.Ledger.GuessExactModel' does not depend on any axioms\n'Models.Ledger.GuessModel' does not depend on any axioms\n'Models.Ledger.GuessSample.guess_agreement' does not depend on any axioms\n'Models.Ledger.LedgerContract.invariant_complete' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.invariant_sound' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.postcondition_complete' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.Overshoot' does not depend on any axioms\n'Models.Ledger.OvershootModel' does not depend on any axioms\n'Models.Ledger.Small' does not depend on any axioms\n'Models.Ledger.Spill' does not depend on any axioms\n'Models.Ledger.Spill.initial' does not depend on any axioms\n'Models.Ledger.SpillEvidence.spill_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.SpillModel' does not depend on any axioms\n'Models.Ledger.SpillModel.initial' does not depend on any axioms\n'Models.Ledger.SpillRawModel' does not depend on any axioms\n'Models.Ledger.SpillRawModel.initial' does not depend on any axioms\n'Models.Ledger.SpillReference.spill_reference' depends on axioms: [propext]\n'Models.Ledger.Tally' does not depend on any axioms\n'Models.Ledger.Tally.initial' does not depend on any axioms\n'Models.Ledger.TallyContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.TallyContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.TallyEvidence.tally_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.TallyEvidence.tally_reference' depends on axioms: [propext]\n'Models.Ledger.TallyModel' does not depend on any axioms\n'Models.Ledger.TallyModel.initial' does not depend on any axioms\n'Models.Ledger.Within' does not depend on any axioms\n'Models.Ledger.belowCheck' does not depend on any axioms\n'Models.Ledger.below_check_sound' depends on axioms: [propext]\n'Models.Ledger.cappedCheck' does not depend on any axioms\n'Models.Ledger.capped_check_complete' depends on axioms: [propext]\n'Models.Ledger.capped_check_sound' depends on axioms: [propext]\n'Models.Ledger.clampRef' does not depend on any axioms\n'Models.Ledger.clamp_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.clamp_initial' does not depend on any axioms\n'Models.Ledger.clamp_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.clamp_reference' depends on axioms: [propext]\n'Models.Ledger.growsCheck' does not depend on any axioms\n'Models.Ledger.grows_check_complete' depends on axioms: [propext]\n'Models.Ledger.grows_check_sound' depends on axioms: [propext]\n'Models.Ledger.guessRef' does not depend on any axioms\n'Models.Ledger.guessSamples' does not depend on any axioms\n'Models.Ledger.guess_agreement' does not depend on any axioms\n'Models.Ledger.guess_reference' depends on axioms: [propext]\n'Models.Ledger.sameNat' does not depend on any axioms\n'Models.Ledger.same_nat_sound' depends on axioms: [propext]\n'Models.Ledger.smallCheck' does not depend on any axioms\n'Models.Ledger.small_check_sound' depends on axioms: [propext]\n'Models.Ledger.spillRef' does not depend on any axioms\n'Models.Ledger.spill_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.spill_reference' depends on axioms: [propext]\n'Models.Ledger.tallyRef' does not depend on any axioms\n'Models.Ledger.tally_free_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.tally_free_reference' depends on axioms: [propext]\n'Models.Ledger.tally_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.tally_reference' depends on axioms: [propext]\n'Models.Ledger.violationCode' does not depend on any axioms\n'Models.Ledger.withinCheck' does not depend on any axioms\n'Models.Ledger.within_check_complete' depends on axioms: [propext]\n'Models.Ledger.within_check_sound' depends on axioms: [propext]\n","stdout_sha256":"0906cff53c4ed452adb799c9fa7c1d2a73a86b3cc74b745342ac5245b8acf079","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Ledger","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Ledger.Below' does not depend on any axioms\n'Models.Ledger.CapContract.invariant_complete' depends on axioms: [propext]\n'Models.Ledger.CapContract.invariant_sound' depends on axioms: [propext]\n'Models.Ledger.CapContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.Capped' does not depend on any axioms\n'Models.Ledger.Clamp' does not depend on any axioms\n'Models.Ledger.Clamp.initial' does not depend on any axioms\n'Models.Ledger.ClampEvidence.clamp_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.ClampEvidence.clamp_initial' does not depend on any axioms\n'Models.Ledger.ClampEvidence.clamp_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.ClampEvidence.clamp_reference' depends on axioms: [propext]\n'Models.Ledger.ClampModel' does not depend on any axioms\n'Models.Ledger.ClampModel.initial' does not depend on any axioms\n'Models.Ledger.FreeContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.FreeEvidence.tally_free_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.FreeEvidence.tally_free_reference' depends on axioms: [propext]\n'Models.Ledger.FreeModel' does not depend on any axioms\n'Models.Ledger.FreeModel.initial' does not depend on any axioms\n'Models.Ledger.Grows' does not depend on any axioms\n'Models.Ledger.Guess' does not depend on any axioms\n'Models.Ledger.GuessContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.GuessContract.precondition_complete' depends on axioms: [propext]\n'Models.Ledger.GuessContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.GuessEquivalence.guess_reference' depends on axioms: [propext]\n'Models.Ledger.GuessExactModel' does not depend on any axioms\n'Models.Ledger.GuessModel' does not depend on any axioms\n'Models.Ledger.GuessSample.guess_agreement' does not depend on any axioms\n'Models.Ledger.LedgerContract.invariant_complete' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.invariant_sound' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.postcondition_complete' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.LedgerContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.Overshoot' does not depend on any axioms\n'Models.Ledger.OvershootModel' does not depend on any axioms\n'Models.Ledger.Small' does not depend on any axioms\n'Models.Ledger.Spill' does not depend on any axioms\n'Models.Ledger.Spill.initial' does not depend on any axioms\n'Models.Ledger.SpillEvidence.spill_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.SpillModel' does not depend on any axioms\n'Models.Ledger.SpillModel.initial' does not depend on any axioms\n'Models.Ledger.SpillRawModel' does not depend on any axioms\n'Models.Ledger.SpillRawModel.initial' does not depend on any axioms\n'Models.Ledger.SpillReference.spill_reference' depends on axioms: [propext]\n'Models.Ledger.Tally' does not depend on any axioms\n'Models.Ledger.Tally.initial' does not depend on any axioms\n'Models.Ledger.TallyContract.postcondition_sound' depends on axioms: [propext]\n'Models.Ledger.TallyContract.precondition_sound' depends on axioms: [propext]\n'Models.Ledger.TallyEvidence.tally_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.TallyEvidence.tally_reference' depends on axioms: [propext]\n'Models.Ledger.TallyModel' does not depend on any axioms\n'Models.Ledger.TallyModel.initial' does not depend on any axioms\n'Models.Ledger.Within' does not depend on any axioms\n'Models.Ledger.belowCheck' does not depend on any axioms\n'Models.Ledger.below_check_sound' depends on axioms: [propext]\n'Models.Ledger.cappedCheck' does not depend on any axioms\n'Models.Ledger.capped_check_complete' depends on axioms: [propext]\n'Models.Ledger.capped_check_sound' depends on axioms: [propext]\n'Models.Ledger.clampRef' does not depend on any axioms\n'Models.Ledger.clamp_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.clamp_initial' does not depend on any axioms\n'Models.Ledger.clamp_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.clamp_reference' depends on axioms: [propext]\n'Models.Ledger.growsCheck' does not depend on any axioms\n'Models.Ledger.grows_check_complete' depends on axioms: [propext]\n'Models.Ledger.grows_check_sound' depends on axioms: [propext]\n'Models.Ledger.guessRef' does not depend on any axioms\n'Models.Ledger.guessSamples' does not depend on any axioms\n'Models.Ledger.guess_agreement' does not depend on any axioms\n'Models.Ledger.guess_reference' depends on axioms: [propext]\n'Models.Ledger.sameNat' does not depend on any axioms\n'Models.Ledger.same_nat_sound' depends on axioms: [propext]\n'Models.Ledger.smallCheck' does not depend on any axioms\n'Models.Ledger.small_check_sound' depends on axioms: [propext]\n'Models.Ledger.spillRef' does not depend on any axioms\n'Models.Ledger.spill_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.spill_reference' depends on axioms: [propext]\n'Models.Ledger.tallyRef' does not depend on any axioms\n'Models.Ledger.tally_free_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.tally_free_reference' depends on axioms: [propext]\n'Models.Ledger.tally_grows' depends on axioms: [propext, Quot.sound]\n'Models.Ledger.tally_reference' depends on axioms: [propext]\n'Models.Ledger.violationCode' does not depend on any axioms\n'Models.Ledger.withinCheck' does not depend on any axioms\n'Models.Ledger.within_check_complete' depends on axioms: [propext]\n'Models.Ledger.within_check_sound' depends on axioms: [propext]\n","stdout_sha256":"0906cff53c4ed452adb799c9fa7c1d2a73a86b3cc74b745342ac5245b8acf079","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.process.json similarity index 94% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.process.json index 5082ab241..cfb980a54 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Main.admission' does not depend on any axioms\n'Models.Main.admitCosts' does not depend on any axioms\n'Models.Main.admit_accepts_cheap' does not depend on any axioms\n'Models.Main.admit_rejects_costly' does not depend on any axioms\n'Models.Main.branchCode' does not depend on any axioms\n'Models.Main.branchStep' does not depend on any axioms\n'Models.Main.branch_refuses_precondition' does not depend on any axioms\n'Models.Main.branch_takes_else' does not depend on any axioms\n'Models.Main.branch_takes_then' does not depend on any axioms\n'Models.Main.chainCode' does not depend on any axioms\n'Models.Main.chainStep' does not depend on any axioms\n'Models.Main.chain_accepts' does not depend on any axioms\n'Models.Main.chain_refuses_precondition' does not depend on any axioms\n'Models.Main.chain_refuses_stage_output' does not depend on any axioms\n'Models.Main.classify' depends on axioms: [propext]\n'Models.Main.classifyChecked' depends on axioms: [propext]\n'Models.Main.classify_eight' depends on axioms: [propext]\n'Models.Main.drainChainStep' does not depend on any axioms\n'Models.Main.drain_chain_accepts' does not depend on any axioms\n'Models.Main.drain_chain_refuses_postcondition' does not depend on any axioms\n'Models.Main.flowCode' does not depend on any axioms\n'Models.Main.flowStep' does not depend on any axioms\n'Models.Main.flow_accepts' does not depend on any axioms\n'Models.Main.flow_refuses_input' does not depend on any axioms\n'Models.Main.flow_refuses_junction' does not depend on any axioms\n'Models.Main.guessChecked' does not depend on any axioms\n'Models.Main.guessOvershoot' does not depend on any axioms\n'Models.Main.guessTwice' does not depend on any axioms\n'Models.Main.guess_accepts' does not depend on any axioms\n'Models.Main.guess_refuses_precondition' does not depend on any axioms\n'Models.Main.ledgerFull' does not depend on any axioms\n'Models.Main.ledgerPost' does not depend on any axioms\n'Models.Main.ledger_accepts' does not depend on any axioms\n'Models.Main.ledger_full_accepts' does not depend on any axioms\n'Models.Main.ledger_full_refuses_output' does not depend on any axioms\n'Models.Main.ledger_refuses_input' does not depend on any axioms\n'Models.Main.ledger_refuses_output' does not depend on any axioms\n'Models.Main.ledger_refuses_precondition' does not depend on any axioms\n'Models.Main.overshootChecked' does not depend on any axioms\n'Models.Main.overshoot_pair_refuses_postcondition' does not depend on any axioms\n'Models.Main.overshoot_refuses_postcondition' does not depend on any axioms\n'Models.Main.pairClamp' does not depend on any axioms\n'Models.Main.pair_clamp_accepts' does not depend on any axioms\n'Models.Main.pair_clamp_refuses_input' does not depend on any axioms\n'Models.Main.quadCode' does not depend on any axioms\n'Models.Main.rawChainStep' does not depend on any axioms\n'Models.Main.raw_chain_accepts' does not depend on any axioms\n'Models.Main.raw_chain_refuses_input' does not depend on any axioms\n'Models.Main.raw_chain_refuses_precondition' does not depend on any axioms\n'Models.Main.respond' depends on axioms: [propext]\n'Models.Main.spillStream' does not depend on any axioms\n'Models.Main.step' does not depend on any axioms\n'Models.Main.stepCode' does not depend on any axioms\n'Models.Main.streamCode' does not depend on any axioms\n'Models.Main.stream_accepts' does not depend on any axioms\n'Models.Main.stream_refuses_output' does not depend on any axioms\n'Models.Main.twiceCode' does not depend on any axioms\n'Models.Main.twice_accepts' does not depend on any axioms\n'Models.Main.twice_refuses' does not depend on any axioms\n'Models.Main.twinStep' does not depend on any axioms\n'Models.Main.twin_accepts' does not depend on any axioms\n'Models.Main.twin_refuses_input' does not depend on any axioms\n'Models.Main.twin_refuses_precondition' does not depend on any axioms\n'Models.Main.valueCode' does not depend on any axioms\n","stdout_sha256":"e3d25ec7612d3d524a16f7635c0ff54fe7ee057f27ef341f9b384b0161610666","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Main.admission' does not depend on any axioms\n'Models.Main.admitCosts' does not depend on any axioms\n'Models.Main.admit_accepts_cheap' does not depend on any axioms\n'Models.Main.admit_rejects_costly' does not depend on any axioms\n'Models.Main.branchCode' does not depend on any axioms\n'Models.Main.branchStep' does not depend on any axioms\n'Models.Main.branch_refuses_precondition' does not depend on any axioms\n'Models.Main.branch_takes_else' does not depend on any axioms\n'Models.Main.branch_takes_then' does not depend on any axioms\n'Models.Main.chainCode' does not depend on any axioms\n'Models.Main.chainStep' does not depend on any axioms\n'Models.Main.chain_accepts' does not depend on any axioms\n'Models.Main.chain_refuses_precondition' does not depend on any axioms\n'Models.Main.chain_refuses_stage_output' does not depend on any axioms\n'Models.Main.classify' depends on axioms: [propext]\n'Models.Main.classifyChecked' depends on axioms: [propext]\n'Models.Main.classify_eight' depends on axioms: [propext]\n'Models.Main.drainChainStep' does not depend on any axioms\n'Models.Main.drain_chain_accepts' does not depend on any axioms\n'Models.Main.drain_chain_refuses_postcondition' does not depend on any axioms\n'Models.Main.flowCode' does not depend on any axioms\n'Models.Main.flowStep' does not depend on any axioms\n'Models.Main.flow_accepts' does not depend on any axioms\n'Models.Main.flow_refuses_input' does not depend on any axioms\n'Models.Main.flow_refuses_junction' does not depend on any axioms\n'Models.Main.guessChecked' does not depend on any axioms\n'Models.Main.guessOvershoot' does not depend on any axioms\n'Models.Main.guessTwice' does not depend on any axioms\n'Models.Main.guess_accepts' does not depend on any axioms\n'Models.Main.guess_refuses_precondition' does not depend on any axioms\n'Models.Main.ledgerFull' does not depend on any axioms\n'Models.Main.ledgerPost' does not depend on any axioms\n'Models.Main.ledger_accepts' does not depend on any axioms\n'Models.Main.ledger_full_accepts' does not depend on any axioms\n'Models.Main.ledger_full_refuses_output' does not depend on any axioms\n'Models.Main.ledger_refuses_input' does not depend on any axioms\n'Models.Main.ledger_refuses_output' does not depend on any axioms\n'Models.Main.ledger_refuses_precondition' does not depend on any axioms\n'Models.Main.overshootChecked' does not depend on any axioms\n'Models.Main.overshoot_pair_refuses_postcondition' does not depend on any axioms\n'Models.Main.overshoot_refuses_postcondition' does not depend on any axioms\n'Models.Main.pairClamp' does not depend on any axioms\n'Models.Main.pair_clamp_accepts' does not depend on any axioms\n'Models.Main.pair_clamp_refuses_input' does not depend on any axioms\n'Models.Main.quadCode' does not depend on any axioms\n'Models.Main.rawChainStep' does not depend on any axioms\n'Models.Main.raw_chain_accepts' does not depend on any axioms\n'Models.Main.raw_chain_refuses_input' does not depend on any axioms\n'Models.Main.raw_chain_refuses_precondition' does not depend on any axioms\n'Models.Main.respond' depends on axioms: [propext]\n'Models.Main.spillStream' does not depend on any axioms\n'Models.Main.step' does not depend on any axioms\n'Models.Main.stepCode' does not depend on any axioms\n'Models.Main.streamCode' does not depend on any axioms\n'Models.Main.stream_accepts' does not depend on any axioms\n'Models.Main.stream_refuses_output' does not depend on any axioms\n'Models.Main.twiceCode' does not depend on any axioms\n'Models.Main.twice_accepts' does not depend on any axioms\n'Models.Main.twice_refuses' does not depend on any axioms\n'Models.Main.twinStep' does not depend on any axioms\n'Models.Main.twin_accepts' does not depend on any axioms\n'Models.Main.twin_refuses_input' does not depend on any axioms\n'Models.Main.twin_refuses_precondition' does not depend on any axioms\n'Models.Main.valueCode' does not depend on any axioms\n","stdout_sha256":"e3d25ec7612d3d524a16f7635c0ff54fe7ee057f27ef341f9b384b0161610666","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.process.json similarity index 91% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.process.json index 1e8216508..0902ea04c 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Pipeline","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Pipeline.Answered' does not depend on any axioms\n'Models.Pipeline.Bounded9' does not depend on any axioms\n'Models.Pipeline.CheckedEvidence.checked_answers' depends on axioms: [propext]\n'Models.Pipeline.CheckedModel' depends on axioms: [propext]\n'Models.Pipeline.CheckedPipeline' depends on axioms: [propext]\n'Models.Pipeline.GlyphPair' does not depend on any axioms\n'Models.Pipeline.GlyphReport' depends on axioms: [propext]\n'Models.Pipeline.GlyphRoute' depends on axioms: [propext]\n'Models.Pipeline.Lit' does not depend on any axioms\n'Models.Pipeline.PairEvidence.pair_correct' does not depend on any axioms\n'Models.Pipeline.PairLit' does not depend on any axioms\n'Models.Pipeline.PairModel' does not depend on any axioms\n'Models.Pipeline.PipelineContract.precondition_sound' does not depend on any axioms\n'Models.Pipeline.PipelineEvidence.pipeline_responds' depends on axioms: [propext]\n'Models.Pipeline.PipelineModel' depends on axioms: [propext]\n'Models.Pipeline.ReportEvidence.report_correct' depends on axioms: [propext]\n'Models.Pipeline.ReportModel' depends on axioms: [propext]\n'Models.Pipeline.Reported' does not depend on any axioms\n'Models.Pipeline.Responds' does not depend on any axioms\n'Models.Pipeline.RouteEvidence.route_bounded' depends on axioms: [propext]\n'Models.Pipeline.RouteModel' depends on axioms: [propext]\n'Models.Pipeline.SegmentCounter' does not depend on any axioms\n'Models.Pipeline.SegmentEvidence.segments_lit' does not depend on any axioms\n'Models.Pipeline.SegmentModel' does not depend on any axioms\n'Models.Pipeline.SessionStream' does not depend on any axioms\n'Models.Pipeline.ShortStream' does not depend on any axioms\n'Models.Pipeline.StreamContract.precondition_sound' depends on axioms: [propext, Quot.sound]\n'Models.Pipeline.StreamModel' does not depend on any axioms\n'Models.Pipeline.TriagePipeline' depends on axioms: [propext]\n'Models.Pipeline.checked_answers' depends on axioms: [propext]\n'Models.Pipeline.pair_correct' does not depend on any axioms\n'Models.Pipeline.pipeline_entry' does not depend on any axioms\n'Models.Pipeline.pipeline_responds' depends on axioms: [propext]\n'Models.Pipeline.report_correct' depends on axioms: [propext]\n'Models.Pipeline.resultCode' does not depend on any axioms\n'Models.Pipeline.route_bounded' depends on axioms: [propext]\n'Models.Pipeline.segments_lit' does not depend on any axioms\n'Models.Pipeline.shortStreamCheck' does not depend on any axioms\n'Models.Pipeline.short_stream_check_sound' depends on axioms: [propext, Quot.sound]\n'Models.Pipeline.symptomatic_sound' does not depend on any axioms\n'Models.Pipeline.triage_actionable' depends on axioms: [propext]\n","stdout_sha256":"0dc16ef42f1b4fafea1004c5a0e46ae569ddbec65791ac9fc89c029e62401683","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Pipeline","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Pipeline.Answered' does not depend on any axioms\n'Models.Pipeline.Bounded9' does not depend on any axioms\n'Models.Pipeline.CheckedEvidence.checked_answers' depends on axioms: [propext]\n'Models.Pipeline.CheckedModel' depends on axioms: [propext]\n'Models.Pipeline.CheckedPipeline' depends on axioms: [propext]\n'Models.Pipeline.GlyphPair' does not depend on any axioms\n'Models.Pipeline.GlyphReport' depends on axioms: [propext]\n'Models.Pipeline.GlyphRoute' depends on axioms: [propext]\n'Models.Pipeline.Lit' does not depend on any axioms\n'Models.Pipeline.PairEvidence.pair_correct' does not depend on any axioms\n'Models.Pipeline.PairLit' does not depend on any axioms\n'Models.Pipeline.PairModel' does not depend on any axioms\n'Models.Pipeline.PipelineContract.precondition_sound' does not depend on any axioms\n'Models.Pipeline.PipelineEvidence.pipeline_responds' depends on axioms: [propext]\n'Models.Pipeline.PipelineModel' depends on axioms: [propext]\n'Models.Pipeline.ReportEvidence.report_correct' depends on axioms: [propext]\n'Models.Pipeline.ReportModel' depends on axioms: [propext]\n'Models.Pipeline.Reported' does not depend on any axioms\n'Models.Pipeline.Responds' does not depend on any axioms\n'Models.Pipeline.RouteEvidence.route_bounded' depends on axioms: [propext]\n'Models.Pipeline.RouteModel' depends on axioms: [propext]\n'Models.Pipeline.SegmentCounter' does not depend on any axioms\n'Models.Pipeline.SegmentEvidence.segments_lit' does not depend on any axioms\n'Models.Pipeline.SegmentModel' does not depend on any axioms\n'Models.Pipeline.SessionStream' does not depend on any axioms\n'Models.Pipeline.ShortStream' does not depend on any axioms\n'Models.Pipeline.StreamContract.precondition_sound' depends on axioms: [propext, Quot.sound]\n'Models.Pipeline.StreamModel' does not depend on any axioms\n'Models.Pipeline.TriagePipeline' depends on axioms: [propext]\n'Models.Pipeline.checked_answers' depends on axioms: [propext]\n'Models.Pipeline.pair_correct' does not depend on any axioms\n'Models.Pipeline.pipeline_entry' does not depend on any axioms\n'Models.Pipeline.pipeline_responds' depends on axioms: [propext]\n'Models.Pipeline.report_correct' depends on axioms: [propext]\n'Models.Pipeline.resultCode' does not depend on any axioms\n'Models.Pipeline.route_bounded' depends on axioms: [propext]\n'Models.Pipeline.segments_lit' does not depend on any axioms\n'Models.Pipeline.shortStreamCheck' does not depend on any axioms\n'Models.Pipeline.short_stream_check_sound' depends on axioms: [propext, Quot.sound]\n'Models.Pipeline.symptomatic_sound' does not depend on any axioms\n'Models.Pipeline.triage_actionable' depends on axioms: [propext]\n","stdout_sha256":"0dc16ef42f1b4fafea1004c5a0e46ae569ddbec65791ac9fc89c029e62401683","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.process.json similarity index 81% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.process.json index 472234f9c..df5bc2052 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Policy","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Policy.Actionable' does not depend on any axioms\n'Models.Policy.Escalates' does not depend on any axioms\n'Models.Policy.PolicyContract.precondition_complete' does not depend on any axioms\n'Models.Policy.PolicyContract.precondition_sound' does not depend on any axioms\n'Models.Policy.PolicyEvidence.policy_escalates' does not depend on any axioms\n'Models.Policy.PolicyModel' does not depend on any axioms\n'Models.Policy.PolicyRules' does not depend on any axioms\n'Models.Policy.PolicyRules.selected' does not depend on any axioms\n'Models.Policy.actionableCheck' does not depend on any axioms\n'Models.Policy.actionable_check_complete' does not depend on any axioms\n'Models.Policy.actionable_check_sound' does not depend on any axioms\n'Models.Policy.emergency_dispatches' does not depend on any axioms\n'Models.Policy.isUrgent' does not depend on any axioms\n'Models.Policy.policy_escalates' does not depend on any axioms\n","stdout_sha256":"270b3535085cfe0cb7e75fc0f2df214d0fd2ec13f84dd5ee6c2c74e95db97b61","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Policy","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Policy.Actionable' does not depend on any axioms\n'Models.Policy.Escalates' does not depend on any axioms\n'Models.Policy.PolicyContract.precondition_complete' does not depend on any axioms\n'Models.Policy.PolicyContract.precondition_sound' does not depend on any axioms\n'Models.Policy.PolicyEvidence.policy_escalates' does not depend on any axioms\n'Models.Policy.PolicyModel' does not depend on any axioms\n'Models.Policy.PolicyRules' does not depend on any axioms\n'Models.Policy.PolicyRules.selected' does not depend on any axioms\n'Models.Policy.actionableCheck' does not depend on any axioms\n'Models.Policy.actionable_check_complete' does not depend on any axioms\n'Models.Policy.actionable_check_sound' does not depend on any axioms\n'Models.Policy.emergency_dispatches' does not depend on any axioms\n'Models.Policy.isUrgent' does not depend on any axioms\n'Models.Policy.policy_escalates' does not depend on any axioms\n","stdout_sha256":"270b3535085cfe0cb7e75fc0f2df214d0fd2ec13f84dd5ee6c2c74e95db97b61","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.process.json similarity index 92% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.process.json index fec0c1c40..dec88c4dc 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Recognizer","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Recognizer.DigitContract.postcondition_complete' depends on axioms: [propext]\n'Models.Recognizer.DigitContract.postcondition_sound' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.digit_net_correct' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.digit_net_exact' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.labeled_agreement' depends on axioms: [propext]\n'Models.Recognizer.DigitModel' depends on axioms: [propext]\n'Models.Recognizer.DigitNet' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.encoded' does not depend on any axioms\n'Models.Recognizer.DigitNet.layer1' does not depend on any axioms\n'Models.Recognizer.DigitNet.layer2' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.layer3' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.layer4' does not depend on any axioms\n'Models.Recognizer.DigitNet.logits' depends on axioms: [propext]\n'Models.Recognizer.RawDigitModel' depends on axioms: [propext]\n'Models.Recognizer.Recognizes' does not depend on any axioms\n'Models.Recognizer.banner' does not depend on any axioms\n'Models.Recognizer.banner.bytes' does not depend on any axioms\n'Models.Recognizer.banner.decoded' does not depend on any axioms\n'Models.Recognizer.digitName' does not depend on any axioms\n'Models.Recognizer.digitNames' does not depend on any axioms\n'Models.Recognizer.digitNames.bytes' does not depend on any axioms\n'Models.Recognizer.digitNames.decoded' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Recognizer.digit_net_correct' depends on axioms: [propext]\n'Models.Recognizer.digit_net_exact' depends on axioms: [propext]\n'Models.Recognizer.digit_net_width' does not depend on any axioms\n'Models.Recognizer.hiddenBias' does not depend on any axioms\n'Models.Recognizer.hiddenBias.bytes' does not depend on any axioms\n'Models.Recognizer.hiddenBias.decoded' does not depend on any axioms\n'Models.Recognizer.hiddenWeights' does not depend on any axioms\n'Models.Recognizer.hiddenWeights.bytes' does not depend on any axioms\n'Models.Recognizer.hiddenWeights.decoded' does not depend on any axioms\n'Models.Recognizer.labeledGlyphs' does not depend on any axioms\n'Models.Recognizer.labeled_agreement' depends on axioms: [propext]\n'Models.Recognizer.outputBias' does not depend on any axioms\n'Models.Recognizer.outputBias.bytes' does not depend on any axioms\n'Models.Recognizer.outputBias.decoded' does not depend on any axioms\n'Models.Recognizer.outputWeights' does not depend on any axioms\n'Models.Recognizer.outputWeights.bytes' does not depend on any axioms\n'Models.Recognizer.outputWeights.decoded' does not depend on any axioms\n'Models.Recognizer.recognizesCheck' does not depend on any axioms\n'Models.Recognizer.recognizes_check_complete' depends on axioms: [propext]\n'Models.Recognizer.recognizes_check_sound' depends on axioms: [propext]\n'Models.Recognizer.sameDigit' does not depend on any axioms\n'Models.Recognizer.same_digit_sound' depends on axioms: [propext]\n","stdout_sha256":"60af4cd88341dc6ed70fd6c68abe9115fc2ca32ba7267d0e09c06d781e05bb3f","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Recognizer","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Recognizer.DigitContract.postcondition_complete' depends on axioms: [propext]\n'Models.Recognizer.DigitContract.postcondition_sound' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.digit_net_correct' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.digit_net_exact' depends on axioms: [propext]\n'Models.Recognizer.DigitEvidence.labeled_agreement' depends on axioms: [propext]\n'Models.Recognizer.DigitModel' depends on axioms: [propext]\n'Models.Recognizer.DigitNet' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.encoded' does not depend on any axioms\n'Models.Recognizer.DigitNet.layer1' does not depend on any axioms\n'Models.Recognizer.DigitNet.layer2' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.layer3' depends on axioms: [propext]\n'Models.Recognizer.DigitNet.layer4' does not depend on any axioms\n'Models.Recognizer.DigitNet.logits' depends on axioms: [propext]\n'Models.Recognizer.RawDigitModel' depends on axioms: [propext]\n'Models.Recognizer.Recognizes' does not depend on any axioms\n'Models.Recognizer.banner' does not depend on any axioms\n'Models.Recognizer.banner.bytes' does not depend on any axioms\n'Models.Recognizer.banner.decoded' does not depend on any axioms\n'Models.Recognizer.digitName' does not depend on any axioms\n'Models.Recognizer.digitNames' does not depend on any axioms\n'Models.Recognizer.digitNames.bytes' does not depend on any axioms\n'Models.Recognizer.digitNames.decoded' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Models.Recognizer.digit_net_correct' depends on axioms: [propext]\n'Models.Recognizer.digit_net_exact' depends on axioms: [propext]\n'Models.Recognizer.digit_net_width' does not depend on any axioms\n'Models.Recognizer.hiddenBias' does not depend on any axioms\n'Models.Recognizer.hiddenBias.bytes' does not depend on any axioms\n'Models.Recognizer.hiddenBias.decoded' does not depend on any axioms\n'Models.Recognizer.hiddenWeights' does not depend on any axioms\n'Models.Recognizer.hiddenWeights.bytes' does not depend on any axioms\n'Models.Recognizer.hiddenWeights.decoded' does not depend on any axioms\n'Models.Recognizer.labeledGlyphs' does not depend on any axioms\n'Models.Recognizer.labeled_agreement' depends on axioms: [propext]\n'Models.Recognizer.outputBias' does not depend on any axioms\n'Models.Recognizer.outputBias.bytes' does not depend on any axioms\n'Models.Recognizer.outputBias.decoded' does not depend on any axioms\n'Models.Recognizer.outputWeights' does not depend on any axioms\n'Models.Recognizer.outputWeights.bytes' does not depend on any axioms\n'Models.Recognizer.outputWeights.decoded' does not depend on any axioms\n'Models.Recognizer.recognizesCheck' does not depend on any axioms\n'Models.Recognizer.recognizes_check_complete' depends on axioms: [propext]\n'Models.Recognizer.recognizes_check_sound' depends on axioms: [propext]\n'Models.Recognizer.sameDigit' does not depend on any axioms\n'Models.Recognizer.same_digit_sound' depends on axioms: [propext]\n","stdout_sha256":"60af4cd88341dc6ed70fd6c68abe9115fc2ca32ba7267d0e09c06d781e05bb3f","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.process.json similarity index 86% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.process.json index 3dc7f958a..ec9bf5fd8 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Session","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Session.Affordable' does not depend on any axioms\n'Models.Session.Bounded' does not depend on any axioms\n'Models.Session.Conserves' does not depend on any axioms\n'Models.Session.SessionContract.invariant_sound' depends on axioms: [propext]\n'Models.Session.SessionContract.precondition_sound' depends on axioms: [propext]\n'Models.Session.SessionEvidence.session_conserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.SessionEvidence.session_initial' does not depend on any axioms\n'Models.Session.SessionEvidence.session_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.SessionModel' does not depend on any axioms\n'Models.Session.SessionModel.initial' does not depend on any axioms\n'Models.Session.SessionStep' does not depend on any axioms\n'Models.Session.SessionStep.initial' does not depend on any axioms\n'Models.Session.Window' does not depend on any axioms\n'Models.Session.affordableCheck' does not depend on any axioms\n'Models.Session.affordable_check_sound' depends on axioms: [propext]\n'Models.Session.boundedCheck' does not depend on any axioms\n'Models.Session.bounded_check_sound' depends on axioms: [propext]\n'Models.Session.session_conserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.session_initial' does not depend on any axioms\n'Models.Session.session_preserves' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"5b3dd4ed72a0f66dee11301a85b919df9929b103d83b10386079e5666ff0ca8c","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Session","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Session.Affordable' does not depend on any axioms\n'Models.Session.Bounded' does not depend on any axioms\n'Models.Session.Conserves' does not depend on any axioms\n'Models.Session.SessionContract.invariant_sound' depends on axioms: [propext]\n'Models.Session.SessionContract.precondition_sound' depends on axioms: [propext]\n'Models.Session.SessionEvidence.session_conserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.SessionEvidence.session_initial' does not depend on any axioms\n'Models.Session.SessionEvidence.session_preserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.SessionModel' does not depend on any axioms\n'Models.Session.SessionModel.initial' does not depend on any axioms\n'Models.Session.SessionStep' does not depend on any axioms\n'Models.Session.SessionStep.initial' does not depend on any axioms\n'Models.Session.Window' does not depend on any axioms\n'Models.Session.affordableCheck' does not depend on any axioms\n'Models.Session.affordable_check_sound' depends on axioms: [propext]\n'Models.Session.boundedCheck' does not depend on any axioms\n'Models.Session.bounded_check_sound' depends on axioms: [propext]\n'Models.Session.session_conserves' depends on axioms: [propext, Quot.sound]\n'Models.Session.session_initial' does not depend on any axioms\n'Models.Session.session_preserves' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"5b3dd4ed72a0f66dee11301a85b919df9929b103d83b10386079e5666ff0ca8c","tool":"lean"} diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.lean b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.lean similarity index 100% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.lean rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.lean diff --git a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.process.json b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.process.json similarity index 87% rename from examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.process.json rename to examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.process.json index c90410840..55567b9eb 100644 --- a/examples/models/expected/verify/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.process.json +++ b/examples/models/expected/verify/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A49cf062e918bdc2f8a44a66473c4435e.Models.Triage","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Triage.Level' does not depend on any axioms\n'Models.Triage.Presentation' does not depend on any axioms\n'Models.Triage.Safe' does not depend on any axioms\n'Models.Triage.Symptomatic' does not depend on any axioms\n'Models.Triage.TriageContract.precondition_sound' does not depend on any axioms\n'Models.Triage.TriageEvidence.triage_safe' depends on axioms: [propext]\n'Models.Triage.TriageModel' depends on axioms: [propext]\n'Models.Triage.TriageScore' depends on axioms: [propext]\n'Models.Triage.TriageScore.features' does not depend on any axioms\n'Models.Triage.TriageScore.scores' does not depend on any axioms\n'Models.Triage.features' does not depend on any axioms\n'Models.Triage.hasSymptom' does not depend on any axioms\n'Models.Triage.isBreathless' does not depend on any axioms\n'Models.Triage.isEmergency' does not depend on any axioms\n'Models.Triage.isRoutine' does not depend on any axioms\n'Models.Triage.symptomaticCheck' does not depend on any axioms\n'Models.Triage.symptomatic_check_sound' does not depend on any axioms\n'Models.Triage.triageBias' does not depend on any axioms\n'Models.Triage.triageBias.bytes' does not depend on any axioms\n'Models.Triage.triageBias.decoded' does not depend on any axioms\n'Models.Triage.triageWeights' does not depend on any axioms\n'Models.Triage.triageWeights.bytes' does not depend on any axioms\n'Models.Triage.triageWeights.decoded' does not depend on any axioms\n'Models.Triage.triage_safe' depends on axioms: [propext]\n'Models.Triage.triage_width' does not depend on any axioms\n","stdout_sha256":"8f5494414737d009f24637a313c3f98408cfea4d290db1d9285d4af1f3d9525c","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A91b57d30cfd6f60128d6c72e374148ef.Models.Triage","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Models.Triage.Level' does not depend on any axioms\n'Models.Triage.Presentation' does not depend on any axioms\n'Models.Triage.Safe' does not depend on any axioms\n'Models.Triage.Symptomatic' does not depend on any axioms\n'Models.Triage.TriageContract.precondition_sound' does not depend on any axioms\n'Models.Triage.TriageEvidence.triage_safe' depends on axioms: [propext]\n'Models.Triage.TriageModel' depends on axioms: [propext]\n'Models.Triage.TriageScore' depends on axioms: [propext]\n'Models.Triage.TriageScore.features' does not depend on any axioms\n'Models.Triage.TriageScore.scores' does not depend on any axioms\n'Models.Triage.features' does not depend on any axioms\n'Models.Triage.hasSymptom' does not depend on any axioms\n'Models.Triage.isBreathless' does not depend on any axioms\n'Models.Triage.isEmergency' does not depend on any axioms\n'Models.Triage.isRoutine' does not depend on any axioms\n'Models.Triage.symptomaticCheck' does not depend on any axioms\n'Models.Triage.symptomatic_check_sound' does not depend on any axioms\n'Models.Triage.triageBias' does not depend on any axioms\n'Models.Triage.triageBias.bytes' does not depend on any axioms\n'Models.Triage.triageBias.decoded' does not depend on any axioms\n'Models.Triage.triageWeights' does not depend on any axioms\n'Models.Triage.triageWeights.bytes' does not depend on any axioms\n'Models.Triage.triageWeights.decoded' does not depend on any axioms\n'Models.Triage.triage_safe' depends on axioms: [propext]\n'Models.Triage.triage_width' does not depend on any axioms\n","stdout_sha256":"8f5494414737d009f24637a313c3f98408cfea4d290db1d9285d4af1f3d9525c","tool":"lean"} diff --git a/examples/models/expected/verify/extract/LexLeanExtract.X49cf062e918bdc2f8a44a66473c4435e.lean b/examples/models/expected/verify/extract/LexLeanExtract.X91b57d30cfd6f60128d6c72e374148ef.lean similarity index 100% rename from examples/models/expected/verify/extract/LexLeanExtract.X49cf062e918bdc2f8a44a66473c4435e.lean rename to examples/models/expected/verify/extract/LexLeanExtract.X91b57d30cfd6f60128d6c72e374148ef.lean diff --git a/examples/models/expected/verify/extract/process.json b/examples/models/expected/verify/extract/process.json index fc0d2e530..f143cda4d 100644 --- a/examples/models/expected/verify/extract/process.json +++ b/examples/models/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X49cf062e918bdc2f8a44a66473c4435e.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X49cf062e918bdc2f8a44a66473c4435e","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Models.Main.classify\",\"Models.Main.classifyChecked\",\"Models.Main.respond\",\"Models.Main.admitCosts\",\"Models.Main.step\",\"Models.Main.ledgerPost\",\"Models.Main.ledgerFull\",\"Models.Main.guessChecked\",\"Models.Main.flowStep\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.instKeyInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOrdInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}},\"uses\":[\"Int\",\"Ord\",\"Ordering\",\"instOrdInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.lessThan.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instBEqOfDecidableEq\",\"instOfNat\",\"BEq.beq\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tmod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instOfNat\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.negate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Neg\",\"Neg.neg\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"Neg\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.lt\",\"Unit.unit\",\"LexLeanCollections.lessThan._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Flows.ClampGuess\",\"kind\":\"definition\",\"module\":\"Models.Flows\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Ledger.ClampModel\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.ClampModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.withinCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.GuessModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.belowCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}]}}}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.ClampModel\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"]},\"inductive\":null},{\"name\":\"Models.Flows.FlowModel\",\"kind\":\"definition\",\"module\":\"Models.Flows\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Flows.ClampGuess\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Flows.ClampGuess\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Models.Flows.ClampGuess\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph\",\"kind\":\"inductive\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Glyphs.Glyph.g0\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g1\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g2\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g3\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g4\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g5\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g6\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g7\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g8\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g9\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}}]}},{\"name\":\"Models.Glyphs.digitOf\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"instOfNatNat\",\"OfNat.ofNat\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.102\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.114\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.135\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.142\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Glyphs.Glyph\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.174\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.180\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g8\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g9\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.184\"}}}}]}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.encode\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.104\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.135\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.122\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.143\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.158\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.189\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.176\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.179\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.189\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.207\",\"parameters\":[{\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.194\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.197\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.205\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.206\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.225\",\"parameters\":[{\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.212\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.215\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.220\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.222\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.225\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.240\",\"parameters\":[{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.230\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.235\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.238\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.237\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.238\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.239\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.240\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.258\",\"parameters\":[{\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.248\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.251\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.249\"},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.254\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.256\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.257\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.258\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Glyphs.Glyph\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.273\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.272\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.273\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.275\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.274\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.275\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.277\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.279\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.278\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.279\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.280\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.281\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.172\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.280\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.281\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.283\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.283\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.208\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.285\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.286\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.286\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.287\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g8\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.288\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.289\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.288\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.289\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g9\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.290\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.291\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.259\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.290\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.291\"}}}}]}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Clamp\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.20\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Models.Ledger.ClampModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Clamp\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Clamp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Clamp\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Guess\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\"]},\"inductive\":null},{\"name\":\"Models.Ledger.GuessModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Guess\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Guess\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Ledger.Guess\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Spill\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Models.Ledger.SpillModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Spill\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Spill\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Spill\"]},\"inductive\":null},{\"name\":\"Models.Ledger.SpillRawModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Spill\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Spill\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Spill\"]},\"inductive\":null},{\"name\":\"Models.Ledger.belowCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.cappedCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.growsCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.smallCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.withinCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Main.admitCosts\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.StreamModel\",\"Models.Pipeline.shortStreamCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.13\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.shortStreamCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.StreamModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.StreamModel\",\"Models.Pipeline.shortStreamCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.classify\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitModel\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitModel\"]},\"inductive\":null},{\"name\":\"Models.Main.classifyChecked\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.RawDigitModel\",\"Models.Recognizer.recognizesCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.RawDigitModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.recognizesCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.RawDigitModel\",\"Models.Recognizer.recognizesCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.flowStep\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Models.Flows.FlowModel\",\"Models.Ledger.cappedCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.40\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Flows.FlowModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}]}}}}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Flows.FlowModel\",\"Models.Ledger.cappedCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.guessChecked\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.withinCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.GuessModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.belowCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}]}}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.ledgerFull\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Ledger.SpillRawModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.growsCheck\",\"Models.Ledger.smallCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.smallCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.SpillRawModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.growsCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}]}}}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.SpillRawModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.growsCheck\",\"Models.Ledger.smallCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.ledgerPost\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Models.Ledger.SpillModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.smallCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.smallCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.SpillModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}]}}}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.SpillModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.smallCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.respond\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.PipelineModel\",\"Models.Triage.Presentation\",\"Models.Triage.symptomaticCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.13\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.symptomaticCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.PipelineModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.PipelineModel\",\"Models.Triage.Presentation\",\"Models.Triage.symptomaticCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.step\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.boundedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.39\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.affordableCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.PipelineModel\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Pipeline.TriagePipeline\",\"Models.Triage.Presentation\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.TriagePipeline\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Pipeline.TriagePipeline\",\"Models.Triage.Presentation\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.SessionStream\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\",\"Models.Pipeline.SessionStream.match_1\",\"Models.Session.SessionModel.initial\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.140\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.76\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.boundedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.affordableCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.103\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.76\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.120\"}}}}}}}}}}}}}]}}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel.initial\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.157\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.160\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.173\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.175\"}}}]}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\",\"Models.Session.SessionModel.initial\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.StreamModel\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Models.Pipeline.SessionStream\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.SessionStream\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Models.Pipeline.SessionStream\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.TriagePipeline\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Policy.PolicyModel\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageModel\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.PolicyModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}},\"uses\":[\"Nat\",\"Models.Policy.PolicyModel\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageModel\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.shortStreamCheck\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1001\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.blt\"]},\"inductive\":null},{\"name\":\"Models.Policy.PolicyModel\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Policy.PolicyRules\",\"Models.Triage.Level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.PolicyRules\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Policy.PolicyRules\",\"Models.Triage.Level\"]},\"inductive\":null},{\"name\":\"Models.Policy.PolicyRules\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"OfNat.ofNat\",\"Models.Policy.isUrgent\",\"Models.Triage.Level\",\"Models.Triage.isEmergency\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.isEmergency\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.23\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.isUrgent\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Models.Policy.isUrgent\",\"Models.Triage.Level\",\"Models.Triage.isEmergency\"]},\"inductive\":null},{\"name\":\"Models.Policy.isUrgent\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Level\",\"Models.Policy.isUrgent.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.35\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Level\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.routine\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.urgent\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.emergency\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitModel\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.logits\",\"Models.Recognizer.DigitNet.match_1\",\"Models.Recognizer.DigitNet.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.187\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.122\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.127\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.140\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.96\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.169\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.166\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.156\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.169\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.96\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.180\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.190\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.193\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.196\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.199\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.202\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.205\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.208\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.210\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.211\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.214\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.216\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.220\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.212\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.222\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"},{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"},{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.logits\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"},{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.233\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.235\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.237\"}}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.logits\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.RawDigitModel\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.hiddenBias\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.hiddenWeights\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.outputBias\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.4\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.outputWeights\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"instOfNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.recognizesCheck\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.beq\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.digitOf\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.digitOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.beq\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.digitOf\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionModel\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Session.SessionStep\",\"Models.Session.Window\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Session.SessionStep\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionStep\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\",\"Models.Session.Window\",\"Models.Session.Window.items\",\"Models.Session.Window.mk\",\"Models.Session.Window.used\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":1,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.Window.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\",\"Models.Session.Window\",\"Models.Session.Window.mk\"]},\"inductive\":null},{\"name\":\"Models.Session.Window\",\"kind\":\"inductive\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Session.Window.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}}}}]}},{\"name\":\"Models.Session.affordableCheck\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\",\"Models.Session.Window\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Session.boundedCheck\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\",\"Models.Session.Window\",\"Models.Session.Window.used\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Triage.Level\",\"kind\":\"inductive\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Triage.Level.routine\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"name\":\"Models.Triage.Level.urgent\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"name\":\"Models.Triage.Level.emergency\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}}]}},{\"name\":\"Models.Triage.Presentation\",\"kind\":\"inductive\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Triage.Presentation.p0\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p1\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p2\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p3\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p4\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p5\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p6\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p7\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}}]}},{\"name\":\"Models.Triage.TriageModel\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.TriageScore\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.6\"}}},\"uses\":[\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageScore\"]},\"inductive\":null},{\"name\":\"Models.Triage.TriageScore\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\",\"Models.Triage.TriageScore.match_1\",\"Models.Triage.TriageScore.match_3\",\"Models.Triage.TriageScore.scores\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.routine\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.181\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.164\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.157\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.156\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.150\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.160\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.164\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.174\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.179\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.routine\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.urgent\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.emergency\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore.scores\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.192\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"discriminant\":\"_uniq.193\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.195\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.197\"}}}]}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\",\"Models.Triage.TriageScore.scores\"]},\"inductive\":null},{\"name\":\"Models.Triage.features\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Models.Triage.Presentation\",\"Models.Triage.features.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.97\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.120\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.114\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.148\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.139\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.142\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.153\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.156\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Presentation\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.186\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.196\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.200\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"]},\"inductive\":null},{\"name\":\"Models.Triage.hasSymptom\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Presentation\",\"Models.Triage.features.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Presentation\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"]},\"inductive\":null},{\"name\":\"Models.Triage.isEmergency\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Level\",\"Models.Triage.isEmergency.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.35\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Level\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.routine\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.urgent\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.emergency\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"]},\"inductive\":null},{\"name\":\"Models.Triage.symptomaticCheck\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.hasSymptom\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.hasSymptom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Models.Triage.Presentation\",\"Models.Triage.hasSymptom\"]},\"inductive\":null},{\"name\":\"Models.Triage.triageBias\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Triage.triageWeights\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.4\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\",\"Models.Glyphs.Glyph.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g0\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g1\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g2\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g3\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g4\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g5\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g6\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g7\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g8\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g9\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.rec\",\"kind\":\"recursor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.encode.match_1\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.casesOn\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Pipeline.SessionStream.match_1\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Policy.isUrgent.match_1\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.casesOn\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.encoded\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Int\",\"List\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Recognizer.hiddenBias\",\"Models.Recognizer.hiddenWeights\",\"Models.Recognizer.DigitNet.layer1.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.156\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.hiddenBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.hiddenWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Recognizer.hiddenBias\",\"Models.Recognizer.hiddenWeights\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer2\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"instDecidableEqBool\",\"instOfNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer3\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"instDecidableEqBool\",\"instOfNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.quotient\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"127\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.56\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}}]}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.quotient\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer4\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Recognizer.outputBias\",\"Models.Recognizer.outputWeights\",\"Models.Recognizer.DigitNet.layer1.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.156\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.outputBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.outputWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Recognizer.outputBias\",\"Models.Recognizer.outputWeights\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.logits\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.encoded\",\"Models.Recognizer.DigitNet.layer1\",\"Models.Recognizer.DigitNet.layer2\",\"Models.Recognizer.DigitNet.layer3\",\"Models.Recognizer.DigitNet.layer4\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.encoded\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer1\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer2\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer3\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer4\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Int\",\"List\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.encoded\",\"Models.Recognizer.DigitNet.layer1\",\"Models.Recognizer.DigitNet.layer2\",\"Models.Recognizer.DigitNet.layer3\",\"Models.Recognizer.DigitNet.layer4\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.match_1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.match_3\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.SessionModel.initial\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.SessionStep.initial\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionStep.initial\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.1\"}}},\"uses\":[\"Models.Session.Window\",\"Models.Session.SessionStep.initial\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionStep.initial\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Models.Session.Window.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.Window.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.4\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Models.Session.Window\",\"Models.Session.Window.mk\"]},\"inductive\":null},{\"name\":\"Models.Session.Window.items\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.Window.mk\",\"kind\":\"constructor\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.Window.used\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.rec\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.emergency\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.rec\",\"kind\":\"recursor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.routine\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.urgent\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\",\"Models.Triage.Presentation.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p0\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p1\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p2\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p3\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p4\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p5\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p6\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p7\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.rec\",\"kind\":\"recursor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.features\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.features\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.features\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Int\",\"List\",\"Models.Triage.Presentation\",\"Models.Triage.features\"]},\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Models.Triage.Level\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.match_3\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Triage.Level\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.scores\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Triage.Presentation\",\"Models.Triage.triageBias\",\"Models.Triage.triageWeights\",\"Models.Triage.TriageScore.features\",\"Models.Triage.TriageScore.scores.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore.features\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.145\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.132\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.134\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.144\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.157\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.triageBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.triageWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.triageBias\",\"Models.Triage.triageWeights\",\"Models.Triage.TriageScore.features\"]},\"inductive\":null},{\"name\":\"Models.Triage.features.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.casesOn\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.isEmergency.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.casesOn\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer1.match_1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.scores.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Neg\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.instDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instMul\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instNegInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tdiv\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tmod\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"000ff34b595f013704d31b540b616943f07c5152f042e08d8eaa26fb72622de7","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X91b57d30cfd6f60128d6c72e374148ef.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X91b57d30cfd6f60128d6c72e374148ef","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Models.Main.classify\",\"Models.Main.classifyChecked\",\"Models.Main.respond\",\"Models.Main.admitCosts\",\"Models.Main.step\",\"Models.Main.ledgerPost\",\"Models.Main.ledgerFull\",\"Models.Main.guessChecked\",\"Models.Main.flowStep\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.instKeyInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOrdInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}},\"uses\":[\"Int\",\"Ord\",\"Ordering\",\"instOrdInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.lessThan.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instBEqOfDecidableEq\",\"instOfNat\",\"BEq.beq\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tmod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instOfNat\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.negate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Neg\",\"Neg.neg\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"Neg\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lessThan.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.lt\",\"Unit.unit\",\"LexLeanCollections.lessThan._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Flows.ClampGuess\",\"kind\":\"definition\",\"module\":\"Models.Flows\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Ledger.ClampModel\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.ClampModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.withinCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.GuessModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.belowCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}]}}}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.ClampModel\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"]},\"inductive\":null},{\"name\":\"Models.Flows.FlowModel\",\"kind\":\"definition\",\"module\":\"Models.Flows\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Flows.ClampGuess\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Flows.ClampGuess\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Models.Flows.ClampGuess\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph\",\"kind\":\"inductive\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Glyphs.Glyph.g0\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g1\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g2\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g3\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g4\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g5\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g6\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g7\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g8\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}},{\"name\":\"Models.Glyphs.Glyph.g9\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]}}]}},{\"name\":\"Models.Glyphs.digitOf\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"instOfNatNat\",\"OfNat.ofNat\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.102\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.114\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.135\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.142\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Glyphs.Glyph\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.174\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.180\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g8\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g9\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.184\"}}}}]}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.encode\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.104\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.135\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.122\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.143\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.158\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.189\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.176\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.179\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.189\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.207\",\"parameters\":[{\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.194\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.197\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.205\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.206\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.225\",\"parameters\":[{\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.212\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.215\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.216\"},{\"kind\":\"fvar\",\"id\":\"_uniq.220\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.222\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.225\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.240\",\"parameters\":[{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.230\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.235\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.238\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.237\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.238\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.239\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.240\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.258\",\"parameters\":[{\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.248\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.251\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.249\"},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.254\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.256\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.257\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.258\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Glyphs.Glyph\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.273\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.272\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.273\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.275\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.274\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.275\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.277\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.279\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.278\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.279\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.280\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.281\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.172\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.280\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.281\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.283\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.283\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.208\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.285\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.286\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.286\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.287\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g8\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.288\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.289\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.288\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.289\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Glyphs.Glyph.g9\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.290\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.291\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.259\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.290\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.291\"}}}}]}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Clamp\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.20\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Models.Ledger.ClampModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Clamp\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Clamp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Clamp\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Guess\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\"]},\"inductive\":null},{\"name\":\"Models.Ledger.GuessModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Guess\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Guess\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Ledger.Guess\"]},\"inductive\":null},{\"name\":\"Models.Ledger.Spill\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Models.Ledger.SpillModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Spill\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Spill\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Spill\"]},\"inductive\":null},{\"name\":\"Models.Ledger.SpillRawModel\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Ledger.Spill\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.Spill\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Ledger.Spill\"]},\"inductive\":null},{\"name\":\"Models.Ledger.belowCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.cappedCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.growsCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.smallCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Ledger.withinCheck\",\"kind\":\"definition\",\"module\":\"Models.Ledger\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Models.Main.admitCosts\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.StreamModel\",\"Models.Pipeline.shortStreamCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.13\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.shortStreamCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.StreamModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.StreamModel\",\"Models.Pipeline.shortStreamCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.classify\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitModel\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitModel\"]},\"inductive\":null},{\"name\":\"Models.Main.classifyChecked\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.RawDigitModel\",\"Models.Recognizer.recognizesCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.RawDigitModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.recognizesCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.RawDigitModel\",\"Models.Recognizer.recognizesCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.flowStep\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Models.Flows.FlowModel\",\"Models.Ledger.cappedCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.40\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Flows.FlowModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}]}}}}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Flows.FlowModel\",\"Models.Ledger.cappedCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.guessChecked\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.withinCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.GuessModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.belowCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}]}}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.GuessModel\",\"Models.Ledger.belowCheck\",\"Models.Ledger.withinCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.ledgerFull\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Ledger.SpillRawModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.growsCheck\",\"Models.Ledger.smallCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.smallCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.SpillRawModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.growsCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}]}}}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.SpillRawModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.growsCheck\",\"Models.Ledger.smallCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.ledgerPost\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Models.Ledger.SpillModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.smallCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.smallCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.SpillModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Ledger.cappedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}]}}}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Ledger.SpillModel\",\"Models.Ledger.cappedCheck\",\"Models.Ledger.smallCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.respond\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.PipelineModel\",\"Models.Triage.Presentation\",\"Models.Triage.symptomaticCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.13\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.symptomaticCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.PipelineModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Pipeline.PipelineModel\",\"Models.Triage.Presentation\",\"Models.Triage.symptomaticCheck\"]},\"inductive\":null},{\"name\":\"Models.Main.step\",\"kind\":\"definition\",\"module\":\"Models.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.boundedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.39\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.affordableCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}}]}}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.PipelineModel\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Pipeline.TriagePipeline\",\"Models.Triage.Presentation\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.TriagePipeline\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Pipeline.TriagePipeline\",\"Models.Triage.Presentation\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.SessionStream\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\",\"Models.Pipeline.SessionStream.match_1\",\"Models.Session.SessionModel.initial\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.140\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.76\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.boundedCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.affordableCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.103\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.76\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.120\"}}}}}}}}}}}}}]}}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionModel.initial\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.157\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.160\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.173\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.175\"}}}]}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Models.Session.SessionModel\",\"Models.Session.Window\",\"Models.Session.affordableCheck\",\"Models.Session.boundedCheck\",\"Models.Session.SessionModel.initial\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.StreamModel\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Models.Pipeline.SessionStream\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Pipeline.SessionStream\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Models.Pipeline.SessionStream\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.TriagePipeline\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Policy.PolicyModel\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageModel\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.PolicyModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}},\"uses\":[\"Nat\",\"Models.Policy.PolicyModel\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageModel\"]},\"inductive\":null},{\"name\":\"Models.Pipeline.shortStreamCheck\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1001\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.blt\"]},\"inductive\":null},{\"name\":\"Models.Policy.PolicyModel\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Policy.PolicyRules\",\"Models.Triage.Level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.PolicyRules\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Policy.PolicyRules\",\"Models.Triage.Level\"]},\"inductive\":null},{\"name\":\"Models.Policy.PolicyRules\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"OfNat.ofNat\",\"Models.Policy.isUrgent\",\"Models.Triage.Level\",\"Models.Triage.isEmergency\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.isEmergency\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.23\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Policy.isUrgent\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Models.Policy.isUrgent\",\"Models.Triage.Level\",\"Models.Triage.isEmergency\"]},\"inductive\":null},{\"name\":\"Models.Policy.isUrgent\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Level\",\"Models.Policy.isUrgent.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.35\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Level\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.routine\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.urgent\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.emergency\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitModel\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.logits\",\"Models.Recognizer.DigitNet.match_1\",\"Models.Recognizer.DigitNet.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.187\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.122\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.127\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.140\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.96\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.169\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.166\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.156\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.169\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.96\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.180\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.190\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.193\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.196\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.199\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.202\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.205\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.208\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.210\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.211\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.214\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.216\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.220\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.212\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.222\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"},{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"},{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.logits\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"},{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.233\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.235\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.237\"}}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.logits\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.RawDigitModel\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.hiddenBias\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.hiddenWeights\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.outputBias\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"6\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.4\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.outputWeights\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"instOfNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.recognizesCheck\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.beq\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.digitOf\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.digitOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Bool\",\"Nat\",\"Nat.beq\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.digitOf\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionModel\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Models.Session.SessionStep\",\"Models.Session.Window\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"uses\":[\"Nat\",\"Prod\",\"Models.Session.SessionStep\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionStep\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\",\"Models.Session.Window\",\"Models.Session.Window.items\",\"Models.Session.Window.mk\",\"Models.Session.Window.used\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":1,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.Window.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\",\"Models.Session.Window\",\"Models.Session.Window.mk\"]},\"inductive\":null},{\"name\":\"Models.Session.Window\",\"kind\":\"inductive\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Session.Window.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]}}}}]}},{\"name\":\"Models.Session.affordableCheck\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\",\"Models.Session.Window\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Session.boundedCheck\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.ble\",\"OfNat.ofNat\",\"Models.Session.Window\",\"Models.Session.Window.used\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Models.Session.Window\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.ble\",\"Models.Session.Window\"]},\"inductive\":null},{\"name\":\"Models.Triage.Level\",\"kind\":\"inductive\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Triage.Level.routine\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"name\":\"Models.Triage.Level.urgent\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"name\":\"Models.Triage.Level.emergency\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}}]}},{\"name\":\"Models.Triage.Presentation\",\"kind\":\"inductive\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Models.Triage.Presentation.p0\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p1\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p2\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p3\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p4\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p5\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p6\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}},{\"name\":\"Models.Triage.Presentation.p7\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]}}]}},{\"name\":\"Models.Triage.TriageModel\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.TriageScore\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.6\"}}},\"uses\":[\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.TriageScore\"]},\"inductive\":null},{\"name\":\"Models.Triage.TriageScore\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\",\"Models.Triage.TriageScore.match_1\",\"Models.Triage.TriageScore.match_3\",\"Models.Triage.TriageScore.scores\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.routine\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.181\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.164\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.157\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.156\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.150\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.160\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.164\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.174\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.179\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.routine\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.urgent\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level.emergency\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore.scores\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.192\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"discriminant\":\"_uniq.193\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.195\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.197\"}}}]}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Presentation\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\",\"Models.Triage.TriageScore.scores\"]},\"inductive\":null},{\"name\":\"Models.Triage.features\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Models.Triage.Presentation\",\"Models.Triage.features.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.97\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.120\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.114\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.148\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.139\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.142\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.153\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.156\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Presentation\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.186\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.196\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.200\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"]},\"inductive\":null},{\"name\":\"Models.Triage.hasSymptom\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Presentation\",\"Models.Triage.features.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Presentation\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p0\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p1\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p2\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p3\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p4\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p5\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p6\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Presentation.p7\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"]},\"inductive\":null},{\"name\":\"Models.Triage.isEmergency\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Models.Triage.Level\",\"Models.Triage.isEmergency.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Level\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.35\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Models.Triage.Level\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.routine\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.urgent\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Models.Triage.Level.emergency\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"]},\"inductive\":null},{\"name\":\"Models.Triage.symptomaticCheck\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.hasSymptom\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.hasSymptom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Models.Triage.Presentation\",\"Models.Triage.hasSymptom\"]},\"inductive\":null},{\"name\":\"Models.Triage.triageBias\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Triage.triageWeights\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.4\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.2\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Nat\",\"Neg\",\"OfNat\",\"instOfNat\",\"Int.instNegInt\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\",\"Models.Glyphs.Glyph.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g0\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g1\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g2\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g3\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g4\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g5\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g6\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g7\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g8\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.g9\",\"kind\":\"constructor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.Glyph.rec\",\"kind\":\"recursor\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Glyphs.encode.match_1\",\"kind\":\"definition\",\"module\":\"Models.Glyphs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.Glyph.casesOn\",\"Models.Glyphs.Glyph.g0\",\"Models.Glyphs.Glyph.g1\",\"Models.Glyphs.Glyph.g2\",\"Models.Glyphs.Glyph.g3\",\"Models.Glyphs.Glyph.g4\",\"Models.Glyphs.Glyph.g5\",\"Models.Glyphs.Glyph.g6\",\"Models.Glyphs.Glyph.g7\",\"Models.Glyphs.Glyph.g8\",\"Models.Glyphs.Glyph.g9\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Pipeline.SessionStream.match_1\",\"kind\":\"definition\",\"module\":\"Models.Pipeline\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Policy.isUrgent.match_1\",\"kind\":\"definition\",\"module\":\"Models.Policy\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.casesOn\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.encoded\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Int\",\"List\",\"Models.Glyphs.Glyph\",\"Models.Glyphs.encode\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Recognizer.hiddenBias\",\"Models.Recognizer.hiddenWeights\",\"Models.Recognizer.DigitNet.layer1.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.156\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.hiddenBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.hiddenWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Recognizer.hiddenBias\",\"Models.Recognizer.hiddenWeights\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer2\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"instDecidableEqBool\",\"instOfNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer3\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"List\",\"instDecidableEqBool\",\"instOfNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.quotient\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"127\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lessThan\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.56\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}}]}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"instDecidableEqBool\",\"instOfNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.lessThan\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.quotient\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer4\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Recognizer.outputBias\",\"Models.Recognizer.outputWeights\",\"Models.Recognizer.DigitNet.layer1.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.156\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.outputBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.outputWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.161\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Recognizer.outputBias\",\"Models.Recognizer.outputWeights\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.logits\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.encoded\",\"Models.Recognizer.DigitNet.layer1\",\"Models.Recognizer.DigitNet.layer2\",\"Models.Recognizer.DigitNet.layer3\",\"Models.Recognizer.DigitNet.layer4\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Glyphs.Glyph\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.encoded\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer1\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer2\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer3\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Recognizer.DigitNet.layer4\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Int\",\"List\",\"Models.Glyphs.Glyph\",\"Models.Recognizer.DigitNet.encoded\",\"Models.Recognizer.DigitNet.layer1\",\"Models.Recognizer.DigitNet.layer2\",\"Models.Recognizer.DigitNet.layer3\",\"Models.Recognizer.DigitNet.layer4\"]},\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.match_1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.match_3\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.SessionModel.initial\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.SessionStep.initial\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.SessionStep.initial\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.1\"}}},\"uses\":[\"Models.Session.Window\",\"Models.Session.SessionStep.initial\"]},\"inductive\":null},{\"name\":\"Models.Session.SessionStep.initial\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Models.Session.Window.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Session.Window\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Session.Window.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.4\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Models.Session.Window\",\"Models.Session.Window.mk\"]},\"inductive\":null},{\"name\":\"Models.Session.Window.items\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.Window.mk\",\"kind\":\"constructor\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Session.Window.used\",\"kind\":\"definition\",\"module\":\"Models.Session\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Session.Window\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Level\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.rec\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.emergency\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.rec\",\"kind\":\"recursor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.routine\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Level.urgent\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.casesOn\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\",\"Models.Triage.Presentation.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p0\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p1\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p2\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p3\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p4\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p5\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p6\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.p7\",\"kind\":\"constructor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.Presentation.rec\",\"kind\":\"recursor\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.features\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Models.Triage.Presentation\",\"Models.Triage.features\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.features\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Int\",\"List\",\"Models.Triage.Presentation\",\"Models.Triage.features\"]},\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Models.Triage.Level\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.match_3\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Models.Triage.Level\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.scores\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Prod\",\"Unit\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Models.Triage.Presentation\",\"Models.Triage.triageBias\",\"Models.Triage.triageWeights\",\"Models.Triage.TriageScore.features\",\"Models.Triage.TriageScore.scores.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Models.Triage.Presentation\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.TriageScore.features\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.145\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.132\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.134\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.144\"}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.157\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.triageBias\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Models.Triage.triageWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}}}}}}}}},\"uses\":[\"Int\",\"List\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"PUnit\",\"Prod\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.triageBias\",\"Models.Triage.triageWeights\",\"Models.Triage.TriageScore.features\"]},\"inductive\":null},{\"name\":\"Models.Triage.features.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Presentation\",\"Models.Triage.Presentation.casesOn\",\"Models.Triage.Presentation.p0\",\"Models.Triage.Presentation.p1\",\"Models.Triage.Presentation.p2\",\"Models.Triage.Presentation.p3\",\"Models.Triage.Presentation.p4\",\"Models.Triage.Presentation.p5\",\"Models.Triage.Presentation.p6\",\"Models.Triage.Presentation.p7\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.isEmergency.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Models.Triage.Level\",\"Models.Triage.Level.casesOn\",\"Models.Triage.Level.emergency\",\"Models.Triage.Level.routine\",\"Models.Triage.Level.urgent\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Recognizer.DigitNet.layer1.match_1\",\"kind\":\"definition\",\"module\":\"Models.Recognizer\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Models.Triage.TriageScore.scores.match_1\",\"kind\":\"definition\",\"module\":\"Models.Triage\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Neg\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.instDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instMul\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instNegInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tdiv\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tmod\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"000ff34b595f013704d31b540b616943f07c5152f042e08d8eaa26fb72622de7","tool":"lean"} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0.lean index 620b3b2cf..f7bd291ae 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [], [], [], [], [], [], [], [], []] }], functions := [ @@ -225,4 +225,4 @@ def denote (glyph : (Models.Glyphs.Glyph)) : _root_.LexLeanPreservation.Obs := theorem root (glyph : (Models.Glyphs.Glyph)) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 glyph)] (_root_.LexLeanPreservation.Rel (__fits_0 glyph) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Models.Main.classify glyph))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 glyph) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/Compose/RustStd.lex.tex similarity index 93% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/Compose/RustStd.lex.tex index 1e2c6070c..3860a5379 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.__wt_0 : @16 := @448 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.root : @1168 := @1169 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.root : @1168 := @1169 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.flags @3 := Models.Glyphs.Glyph @4 := #0 -@5 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.__enc_0 +@5 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -252,7 +252,7 @@ @448 := fun (__v : @3) => Models.Glyphs.Glyph.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 @407 @434 @449 := @5 @30 -@451 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.__wt_0 @30 +@451 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.__wt_0 @30 @452 := @21 @18 @454 := @452 @449 @22 @457 := Prod.{0, 0} @57 @18 @@ -271,7 +271,7 @@ @476 := LexLeanTarget.TargetSyntax.Expr.value @472 @473 @481 := LexLeanTarget.TargetSyntax.Function.mk @471 @23 @472 @476 @486 := List.getD.{0} @468 @470 @9 @481 -@490 := fun (__e_n : @57) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.root @4 @9 +@490 := fun (__e_n : @57) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.root @4 @9 @495 := @7 @66 @79 @88 @68 @28 @498 := @27 @83 @76 @66 @500 := @452 @79 @68 @@ -329,13 +329,13 @@ @614 := @608 @53 @615 := @54 @454 @616 := @615 @604 -@617 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.denote +@617 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.denote @618 := @617 @30 -@619 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.__fits_0 +@619 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.__fits_0 @620 := @619 @30 @622 := Models.Main.classify @30 @624 := LexLeanTarget.TargetSyntax.Value.nat @622 -@626 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.root @30 +@626 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.root @30 @627 := Bool @628 := Ne.{1} @629 := LexLeanPreservation.Obs diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/RustStd.lean index acfc0ed0b..b6e290d73 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -231,4 +231,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1.lean index 2ddb16b4e..f0ddf68d7 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [], [], [], [], [], [], [], [], []] }], functions := [ @@ -242,4 +242,4 @@ def denote (glyph : (Models.Glyphs.Glyph)) : _root_.LexLeanPreservation.Obs := theorem root (glyph : (Models.Glyphs.Glyph)) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 glyph)] (_root_.LexLeanPreservation.Rel (__fits_0 glyph) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) _root_.LexLeanTarget.TargetSyntax.Value.nat) (Models.Main.classifyChecked glyph))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 glyph) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/Compose/RustStd.lex.tex similarity index 93% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/Compose/RustStd.lex.tex index f6dafc6a7..777bf8f48 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.__wt_0 : @16 := @448 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.root : @1181 := @1182 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.root : @1181 := @1182 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.flags @3 := Models.Glyphs.Glyph @4 := #0 -@5 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.__enc_0 +@5 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -252,7 +252,7 @@ @448 := fun (__v : @3) => Models.Glyphs.Glyph.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 @407 @434 @449 := @5 @30 -@451 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.__wt_0 @30 +@451 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.__wt_0 @30 @452 := @21 @18 @454 := @452 @449 @22 @455 := Prod.{0, 0} @@ -272,7 +272,7 @@ @476 := LexLeanTarget.TargetSyntax.Expr.value @472 @473 @481 := LexLeanTarget.TargetSyntax.Function.mk @471 @23 @472 @476 @486 := List.getD.{0} @468 @470 @9 @481 -@490 := fun (__e_n : @57) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.root @4 @9 +@490 := fun (__e_n : @57) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.root @4 @9 @495 := @7 @66 @79 @88 @68 @28 @498 := @27 @83 @76 @66 @500 := @452 @79 @68 @@ -330,9 +330,9 @@ @614 := @608 @53 @615 := @54 @454 @616 := @615 @604 -@617 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.denote +@617 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.denote @618 := @617 @30 -@619 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.__fits_0 +@619 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.__fits_0 @620 := @619 @30 @622 := Models.Main.classifyChecked @30 @623 := Bool @@ -341,7 +341,7 @@ @631 := LexLeanPreservation.encPair @623 @623 @626 @626 @632 := LexLeanTarget.TargetSyntax.Value.nat @638 := LexLeanPreservation.encExcept @625 @57 @631 @632 @622 -@640 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.root @30 +@640 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.root @30 @641 := Ne.{1} @642 := LexLeanPreservation.Obs @643 := @641 @642 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/RustStd.lean index b44133f2a..b65d9f83d 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -247,4 +247,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2.lean index 948bebb0d..2a764731d 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [], [], [], [], [], [], []] }, @@ -214,4 +214,4 @@ def denote (presentation : (Models.Triage.Presentation)) : _root_.LexLeanPreserv theorem root (presentation : (Models.Triage.Presentation)) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 presentation)] (_root_.LexLeanPreservation.Rel (__fits_0 presentation) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) _root_.LexLeanTarget.TargetSyntax.Value.nat) (Models.Main.respond presentation))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 presentation) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/Compose/RustStd.lex.tex similarity index 93% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/Compose/RustStd.lex.tex index dd6504b1d..0a7bf0f9e 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/Compose/RustStd.lex.tex @@ -1,40 +1,40 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_0 : @16 := @392 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_0 : @16 := @392 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_1 : @399 := @481 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_1 : @399 := @481 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.root : @1214 := @1215 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.root : @1214 := @1215 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.flags @3 := Models.Triage.Presentation @4 := #0 -@5 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.__enc_0 +@5 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -239,7 +239,7 @@ @392 := fun (__v : @3) => Models.Triage.Presentation.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 @393 := Models.Triage.Level -@395 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.__enc_1 @4 +@395 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.__enc_1 @4 @396 := @8 @192 @398 := @13 @395 @396 @399 := (__v : @393) -> @398 @@ -283,7 +283,7 @@ @474 := @468 (@188 @455) @53 @481 := fun (__v : @393) => Models.Triage.Level.casesOn.{0} @400 @4 @432 @453 @474 @482 := @5 @30 -@484 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_0 @30 +@484 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_0 @30 @485 := @21 @18 @487 := @485 @482 @22 @488 := Prod.{0, 0} @@ -303,7 +303,7 @@ @509 := LexLeanTarget.TargetSyntax.Expr.value @505 @506 @514 := LexLeanTarget.TargetSyntax.Function.mk @504 @23 @505 @509 @519 := List.getD.{0} @501 @503 @9 @514 -@523 := fun (__e_n : @57) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.root @4 @9 +@523 := fun (__e_n : @57) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.root @4 @9 @528 := @7 @66 @79 @88 @68 @28 @531 := @27 @83 @76 @66 @533 := @485 @79 @68 @@ -361,9 +361,9 @@ @647 := @641 @53 @648 := @54 @487 @649 := @648 @637 -@650 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.denote +@650 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.denote @651 := @650 @30 -@652 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.__fits_0 +@652 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.__fits_0 @653 := @652 @30 @655 := Models.Main.respond @30 @656 := Bool @@ -372,7 +372,7 @@ @664 := LexLeanPreservation.encPair @656 @656 @659 @659 @665 := LexLeanTarget.TargetSyntax.Value.nat @671 := LexLeanPreservation.encExcept @658 @57 @664 @665 @655 -@673 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.root @30 +@673 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.root @30 @674 := Ne.{1} @675 := LexLeanPreservation.Obs @676 := @674 @675 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/RustStd.lean index c303e84e3..d5928d966 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -207,4 +207,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3.lean index a47446710..85dfdbfc2 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat]] }], functions := [ @@ -129,4 +129,4 @@ def denote (costs : (List Nat)) : _root_.LexLeanPreservation.Obs := theorem root (costs : (List Nat)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) costs)] (_root_.LexLeanPreservation.Rel (__fits_0 costs) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))) (Models.Main.admitCosts costs))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 costs) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/Compose/RustStd.lex.tex similarity index 94% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/Compose/RustStd.lex.tex index 4f5cb11fd..ad33de914 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.__wt_0 : @16 := @440 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.root : @1207 := @1208 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.root : @1207 := @1208 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.flags @3 := Models.Session.Window @4 := #0 -@6 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.__enc_0 @4 +@6 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -304,7 +304,7 @@ @566 := LexLeanTarget.TargetSyntax.Expr.value @562 @563 @571 := LexLeanTarget.TargetSyntax.Function.mk @561 @77 @562 @566 @576 := List.getD.{0} @558 @560 @9 @571 -@580 := fun (__e_n : @27) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.root @4 @9 +@580 := fun (__e_n : @27) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.root @4 @9 @581 := @185 @445 @582 := @444 @117 @584 := @13 @582 @30 @@ -338,9 +338,9 @@ @635 := @629 @106 @636 := @107 @544 @637 := @636 @625 -@638 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.denote +@638 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.denote @639 := @638 @32 -@640 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.__fits_0 +@640 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.__fits_0 @641 := @640 @32 @643 := Models.Main.admitCosts @32 @644 := Bool @@ -351,7 +351,7 @@ @657 := LexLeanPreservation.encExcept @646 @660 := @657 @441 @655 @444 @664 := @657 @649 @655 @660 @643 -@666 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.root @32 +@666 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.root @32 @667 := Ne.{1} @668 := LexLeanPreservation.Obs @669 := @667 @668 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/RustStd.lean index 1b8904eee..5a8e07891 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -121,4 +121,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4.lean index 0216c28bf..f5881b913 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat]] }], functions := [ @@ -75,4 +75,4 @@ def denote (window : (Models.Session.Window)) (cost : Nat) : _root_.LexLeanPrese theorem root (window : (Models.Session.Window)) (cost : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 window), (_root_.LexLeanTarget.TargetSyntax.Value.nat cost)] (_root_.LexLeanPreservation.Rel (__fits_0 window cost) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair __enc_0 _root_.LexLeanTarget.TargetSyntax.Value.nat)) (Models.Main.step window cost))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 window cost) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/Compose/RustStd.lex.tex similarity index 93% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/Compose/RustStd.lex.tex index 22cb41927..ac7ff1d16 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.__wt_0 : @16 := @440 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.root : @1229 := @1230 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.root : @1229 := @1230 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.flags @3 := Models.Session.Window @4 := #0 -@5 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.__enc_0 +@5 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -237,7 +237,7 @@ @439 := @13 (@404 @76) @10 @440 := fun (__s : @3) => @436 @441 := @5 @30 -@443 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.__wt_0 @30 +@443 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.__wt_0 @30 @444 := @21 @32 @445 := @56 @32 @447 := @13 @444 @23 @@ -265,7 +265,7 @@ @478 := LexLeanTarget.TargetSyntax.Expr.value @474 @475 @483 := LexLeanTarget.TargetSyntax.Function.mk @473 @77 @474 @478 @488 := List.getD.{0} @470 @472 @9 @483 -@492 := fun (__e_n : @27) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.root @4 @9 +@492 := fun (__e_n : @27) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.root @4 @9 @493 := @185 @444 @494 := @21 @117 @496 := @13 @494 @30 @@ -328,9 +328,9 @@ @604 := @598 @544 @605 := @107 @451 @606 := @605 @594 -@607 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.denote +@607 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.denote @609 := @607 @30 @32 -@610 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.__fits_0 +@610 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.__fits_0 @612 := @610 @30 @32 @615 := Models.Main.step @30 @32 @616 := Bool @@ -341,7 +341,7 @@ @626 := @622 @616 @616 @621 @621 @630 := @622 @3 @27 @5 @21 @636 := LexLeanPreservation.encExcept @618 @620 @626 @630 @615 -@639 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.root @30 @32 +@639 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.root @30 @32 @640 := Ne.{1} @641 := LexLeanPreservation.Obs @642 := @640 @641 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/RustStd.lean index 9aebb3066..afd7b85b8 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -63,4 +63,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5.lean index 7cf37ba95..7dace7261 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -72,4 +72,4 @@ def denote (s : Nat) (x : Nat) : _root_.LexLeanPreservation.Obs := theorem root (s : Nat) (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreservation.Rel (__fits_0 s x) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) (Models.Main.ledgerPost s x))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 s x) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/Compose/RustStd.lex.tex similarity index 94% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/Compose/RustStd.lex.tex index 7184a08d4..773805903 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.root : @932 := @933 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -84,7 +84,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.root @17 @72 + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -195,9 +195,9 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.denote +@321 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.__fits_0 +@324 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.__fits_0 @326 := @324 @4 @15 @329 := Models.Main.ledgerPost @4 @15 @330 := Bool @@ -208,7 +208,7 @@ @339 := @335 @330 @330 @334 @334 @343 := @335 @3 @3 @5 @5 @349 := LexLeanPreservation.encExcept @332 @333 @339 @343 @329 -@352 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.root @4 @15 +@352 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.root @4 @15 @353 := Ne.{1} @354 := LexLeanPreservation.Obs @355 := @353 @354 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/RustStd.lean index 55df8a9b2..d1c46b698 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -62,4 +62,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6.lean index 0a363ddf9..112c5f073 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -80,4 +80,4 @@ def denote (s : Nat) (x : Nat) : _root_.LexLeanPreservation.Obs := theorem root (s : Nat) (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreservation.Rel (__fits_0 s x) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) (Models.Main.ledgerFull s x))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 s x) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/Compose/RustStd.lex.tex similarity index 94% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/Compose/RustStd.lex.tex index 36bc1cb06..84cc0c587 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.root : @932 := @933 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -84,7 +84,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.root @17 @72 + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -195,9 +195,9 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.denote +@321 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.__fits_0 +@324 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.__fits_0 @326 := @324 @4 @15 @329 := Models.Main.ledgerFull @4 @15 @330 := Bool @@ -208,7 +208,7 @@ @339 := @335 @330 @330 @334 @334 @343 := @335 @3 @3 @5 @5 @349 := LexLeanPreservation.encExcept @332 @333 @339 @343 @329 -@352 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.root @4 @15 +@352 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.root @4 @15 @353 := Ne.{1} @354 := LexLeanPreservation.Obs @355 := @353 @354 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/RustStd.lean index ccc4f5d1c..a01fe2f90 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -70,4 +70,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7.lean similarity index 98% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7.lean index b4357d8c2..2ff244563 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -72,4 +72,4 @@ def denote (x : Nat) : _root_.LexLeanPreservation.Obs := theorem root (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreservation.Rel (__fits_0 x) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) _root_.LexLeanTarget.TargetSyntax.Value.nat) (Models.Main.guessChecked x))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 x) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/Compose/RustStd.lex.tex similarity index 93% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/Compose/RustStd.lex.tex index 1d8ca9f6c..1dedc80f2 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.root : @838 := @839 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.root : @838 := @839 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 -@95 := fun (__e_n : @3) => LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.root @17 @60 +@95 := fun (__e_n : @3) => LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,9 +158,9 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.denote +@271 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.denote @272 := @271 @4 -@273 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.__fits_0 +@273 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.__fits_0 @274 := @273 @4 @276 := Models.Main.guessChecked @4 @277 := Bool @@ -168,7 +168,7 @@ @280 := LexLeanTarget.TargetSyntax.Value.bool @285 := LexLeanPreservation.encPair @277 @277 @280 @280 @291 := LexLeanPreservation.encExcept @279 @3 @285 @5 @276 -@293 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.root @4 +@293 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.root @4 @294 := Ne.{1} @295 := LexLeanPreservation.Obs @296 := @294 @295 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/RustStd.lean similarity index 98% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/RustStd.lean index ff86ff29a..fe696ff74 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -62,4 +62,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8.lean index e5285606d..b16804d27 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8.lean @@ -19,7 +19,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8 +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -115,4 +115,4 @@ def denote (s : Nat) (x : Nat) : _root_.LexLeanPreservation.Obs := theorem root (s : Nat) (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreservation.Rel (__fits_0 s x) ((_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encExcept (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool) _root_.LexLeanTarget.TargetSyntax.Value.nat))) (Models.Main.flowStep s x))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 s x) -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8 +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/Compose/RustStd.lex.tex similarity index 94% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/Compose/RustStd.lex.tex rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/Compose/RustStd.lex.tex index 73fe7e96b..338cd4812 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/Compose/RustStd.lex.tex +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8, - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8, + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.root : @938 := @939 { - all: [LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.root], +theorem LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.root : @938 := @939 { + all: [LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.program -@1 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.krate -@2 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.flags +@0 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.program +@1 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.krate +@2 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -84,7 +84,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.root @17 @72 + LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -195,9 +195,9 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.denote +@321 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.__fits_0 +@324 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.__fits_0 @326 := @324 @4 @15 @329 := Models.Main.flowStep @4 @15 @330 := Bool @@ -211,7 +211,7 @@ @347 := @344 @3 @342 @5 @351 := @338 @3 @335 @5 @347 @355 := @344 @336 @342 @351 @329 -@358 := LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.root @4 @15 +@358 := LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.root @4 @15 @359 := Ne.{1} @360 := LexLeanPreservation.Obs @361 := @359 @360 diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/RustStd.lean similarity index 99% rename from examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/RustStd.lean rename to examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/RustStd.lean index a95b527b0..f46f35340 100644 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/RustStd.lean +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd +namespace LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -102,4 +102,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd +end LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd diff --git a/examples/models/expected/verify/preserve/audit.txt b/examples/models/expected/verify/preserve/audit.txt index 1bff85617..b0b0a0a69 100644 --- a/examples/models/expected/verify/preserve/audit.txt +++ b/examples/models/expected/verify/preserve/audit.txt @@ -7737,75 +7737,75 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/models/expected/verify/preserve/preservation.json b/examples/models/expected/verify/preserve/preservation.json index 052cee848..d9e0cad81 100644 --- a/examples/models/expected/verify/preserve/preservation.json +++ b/examples/models/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":205391,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":17234,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd","sha256":"8f3a7850020d5c75c5aafcf212bf4020c5b1334529be057bd58872d93593d814","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd","sha256":"d6e98d5cdf153e75be783d1296b26508707250e3888bc1a86cd52a1aeecf4ba3","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"514db658d4359676b9e7cd9b428386039f1af0edcb4583a5bef8ee72dea97bd9","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.root"},{"byte_length":215569,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":17449,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd","sha256":"515c044b41ecc10b2c1572267529ffc9895f8edfa8f55dfcd384ab75512c23c4","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd","sha256":"46332f6cb60813b476f5a3d229aa3e267dff82e995f8a4ce9127c451a0738b47","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"8770e30567c6e91e5cabf7fc549a0e98f2b5617371473a091ac753d759af143e","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.root"},{"byte_length":86246,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":18513,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd","sha256":"9dca56b40d2f4b4fcaa134ff4848cddfe1fc5b4039e04521bf337248f4cc8d5f","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd","sha256":"9688b4def7551eaeabfce4da7454ba90f2cafbb7d2b1d736d4645b6e76a9b297","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"0da7f8aeaf67fd4bb524b532fe05d10d7684cbd9e41d7df50a5b491606a9714c","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.root"},{"byte_length":41340,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":17868,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd","sha256":"7ef3090972dd0f6b829b8a4db418f9683ebbea57dba78c8cd86259c144fb1c31","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd","sha256":"d275df28ef7dd9550eb84370561989f3b39abf0112de4bfe7fa4e04247debd91","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"b4ffca48952749367595b34814a8ca18c053155995d85c8894deb2f068655df3","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.root"},{"byte_length":16488,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":17788,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd","sha256":"8d168e8893d97461bb1bc58823c4120ab91531f7fab6db20d78bbedb3047d48c","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd","sha256":"28c7495af09fe967ba6cfdcc714522c67220f26c7e76d11937cf050e1fb0b27a","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"b851e4e02ca61ea193a8cf8ec21799599355c0b587d6bddb447e630541fab87f","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd","sha256":"6ac5666f51f7ce14207e3ab2786ed0ac167d1a378908e4b8bb02e2b8af340d3b","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd","sha256":"00cb3aa1573f966fec20c8034fcf5818a5cfc6d7a82e138676ebdb145cc72145","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"41c656e91c6ba759d5574f79445070c7dceba2e51e90107ce2fb8e194d5c7124","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd","sha256":"7cd6e45f839b9124360d10cb98b6d9f9eb9e949bbeb8e1610244838686a99994","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd","sha256":"0c9376cb830d76327a6b43154220e4b55cb53e3e985fa81e4f8d9cdfc3f6bc9e","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"db5df65996d98d84a49096a1036623e563a74f20cb371e439b706ba178353cee","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":12210,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd","sha256":"a31f28194d0fd9874b0dd9579830a091fb4d9865b1b415b1944d704a8635df57","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd","sha256":"be8958db21e8d1155ad1bc6b01ea4a8bfaa8f0037dc99d682f144ba3d44394fd","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"743f6dba5283a400241b8eb0624689f2dda8dddfcba67ea00d3fd1ab1ea6a85b","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.root"},{"byte_length":28208,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":13516,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd","sha256":"418840143c917b517ee3793b31bc8bcd9d9acee07eeec925e4a8efcce8e22979","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd","sha256":"90fa4da1c04bad779f4dbd5387ed22dda4ee3188c5a459dd46476c2242380666","target":"rust-std","theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"1520b9593efda8665c1889f3988b00192d601c543b9875bb3d3aa3647c5b9f94","targets":["rust-std"],"theorem":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":205391,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":17234,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd","sha256":"88e2625ee1ad1c9c40a8b9347ef3cad43b593dc0f315b6aeb8d4d2f11b2425d1","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd","sha256":"58441c1d36ed8049fb4e74d9e841b8a9d945261c86693a1e44df67bb455233e6","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"7e29cd4f8cacd3e2c5b5ff88c422f45662bd717c501c29aa466b2e19d473ec28","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.root"},{"byte_length":215569,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":17449,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd","sha256":"5b9b0db0bdeda0fa8d0774fab0f031f44660ddc1841c5b7ec213012b904146a8","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd","sha256":"71e4f716c241c0cecf737023274c5c0d71d86e65689241b8762ba75c23ad2dab","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"3857fcaea84106e4e65bdbfbaa097fcbfc97c14e6aabca7b00789826e598c803","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.root"},{"byte_length":86246,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":18513,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd","sha256":"ed1d37b1b371df25c84d825fd138b5cb576ad3a976e11693364dd94437396ed8","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd","sha256":"d457be31ff91213b77f9d5a06a13a84f20a68b030c7eb9c5012c05004e2ac45d","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"0344d037231b31a600ab2dec4292344d0090032d350daa6751865c205de446ab","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.root"},{"byte_length":41340,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":17868,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd","sha256":"afcaf15775ebf672444ef3e5b38fbea1fb611edafee45f7c2d8152647958fbca","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd","sha256":"1ea38679b666f685b305ea253249d1408b1879ccce6f15bbe43422157ecb6013","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"7b28a5f3df92871dfa03d879ebc72b406f80638eea871d1a7f15b5d8736daf0e","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.root"},{"byte_length":16488,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":17788,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd","sha256":"8e26dd0e353d74437b4e4032e3addd8d3f805e3db87a03b2448d00b3d1fbca14","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd","sha256":"41b227935dca5d3a9c7fbc64f0223bec1ad0a7243ba1ff866d2463b106c526c6","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"677b3e1d04a642d79c95364e756c957033750ed3f458705753f41fbe7249795b","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd","sha256":"705de7d5ade41c308c6f46b9472fcfe4469ee76ab24e9f8e01b25070de372a83","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd","sha256":"49f00fe72c52214d693ad9cc2d952bace977d0840e527471d445f86720882517","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"1590cc829191bc917e32d35f773116f58ca61297b7a58eea0e61834f5b6a5826","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd","sha256":"ac18355f31ed1cd2331f6c247d57b8a4af5c4e6bbf75d6e3b58c1f54c7b5580f","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd","sha256":"0cee23c0892e11b0e7ad7f8fe0096df04d66159f1fccef987477ebabf5819835","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"c23304418cdc8175168bdd6da1c8d3d70e67da8ea590a0d9985623382ff7874e","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":12210,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd","sha256":"deee2a75053e5bbd23999687f8409293483816edb6b2a5d32a62f371e1d98d5b","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd","sha256":"df460b5f7a165ab67055ca487382cb9117e33b10431d4f9fa4f6d322faa1ad94","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"4b0025d58eb0f9df5c712c00bd92808c416f4de84f9e055c128f4fbedaa3f00b","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.root"},{"byte_length":28208,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":13516,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd","sha256":"d84ad9447f2b695ee9c4c2efdaaa604bea742336c7fb3b0308e3de015b9ecaae","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd","sha256":"1d10511800875e2259addfea828b2fd06fdc4978cd768b42027b30390770c468","target":"rust-std","theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"2453c6f03b1743e58ade74f5cf830220c6bd6cf3664b9056e70b7772af906d58","targets":["rust-std"],"theorem":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/models/expected/verify/probe/LexLeanProbe.P49cf062e918bdc2f8a44a66473c4435e.lean b/examples/models/expected/verify/probe/LexLeanProbe.P91b57d30cfd6f60128d6c72e374148ef.lean similarity index 100% rename from examples/models/expected/verify/probe/LexLeanProbe.P49cf062e918bdc2f8a44a66473c4435e.lean rename to examples/models/expected/verify/probe/LexLeanProbe.P91b57d30cfd6f60128d6c72e374148ef.lean diff --git a/examples/models/expected/verify/probe/process.json b/examples/models/expected/verify/probe/process.json index db0e0e950..ef2bfcdd3 100644 --- a/examples/models/expected/verify/probe/process.json +++ b/examples/models/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P49cf062e918bdc2f8a44a66473c4435e.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P49cf062e918bdc2f8a44a66473c4435e","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P91b57d30cfd6f60128d6c72e374148ef.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P91b57d30cfd6f60128d6c72e374148ef","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json deleted file mode 100644 index 973eb846a..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json deleted file mode 100644 index ba5b6e781..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json deleted file mode 100644 index 1f96ebb2c..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json deleted file mode 100644 index fe5c3f7bf..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json deleted file mode 100644 index 3f1c68ae9..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json deleted file mode 100644 index 1f8b71cfc..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json deleted file mode 100644 index 679bafc59..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json deleted file mode 100644 index 612477e7a..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json deleted file mode 100644 index 32eb297f7..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json deleted file mode 100644 index a9e6a339e..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json deleted file mode 100644 index 114f01bf3..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json deleted file mode 100644 index fdc79e741..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json deleted file mode 100644 index 1bcab7e87..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json deleted file mode 100644 index 000016a64..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json deleted file mode 100644 index 34b4a086d..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json deleted file mode 100644 index d94123f44..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json deleted file mode 100644 index d5a6c7f6d..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json deleted file mode 100644 index 2eb19a121..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json deleted file mode 100644 index 68844807f..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json deleted file mode 100644 index d8798b018..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json deleted file mode 100644 index a9c58852e..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json deleted file mode 100644 index 9f6288d25..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json deleted file mode 100644 index e3ce5e566..000000000 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json similarity index 58% rename from examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json rename to examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json index fd0452a57..4e18d040e 100644 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json new file mode 100644 index 000000000..91f5554bf --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json new file mode 100644 index 000000000..0d38b63f2 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json similarity index 58% rename from examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json rename to examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json index e5d88c65e..5e2444380 100644 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json new file mode 100644 index 000000000..76edd3899 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json new file mode 100644 index 000000000..12136cfbb --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json similarity index 58% rename from examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json rename to examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json index 0c5f5790a..f5f85aea4 100644 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json new file mode 100644 index 000000000..c62e9cff5 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json new file mode 100644 index 000000000..014785ef2 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json similarity index 58% rename from examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json rename to examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json index 94676534b..420cc32c0 100644 --- a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json new file mode 100644 index 000000000..ee4c7dc0f --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json new file mode 100644 index 000000000..d1651e7b0 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json new file mode 100644 index 000000000..e7439d78f --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json new file mode 100644 index 000000000..91cf5521b --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json new file mode 100644 index 000000000..c87a8f530 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json new file mode 100644 index 000000000..a929667de --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json new file mode 100644 index 000000000..ed1784d6b --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json new file mode 100644 index 000000000..ffece195d --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json new file mode 100644 index 000000000..18def3388 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json new file mode 100644 index 000000000..c732373e3 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json new file mode 100644 index 000000000..699b72b21 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json new file mode 100644 index 000000000..19eeebc1f --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json new file mode 100644 index 000000000..f10d0e520 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json new file mode 100644 index 000000000..b43f32e5f --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json new file mode 100644 index 000000000..e11611df1 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json new file mode 100644 index 000000000..56e47e906 --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json new file mode 100644 index 000000000..0dfc50aae --- /dev/null +++ b/examples/models/expected/verify/process/leanchecker/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json index e61bc15c6..de89e919d 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"86d0558d668f26b2d92d282894a45adac3e578a2715d9bebb5b4213783bda6ce","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"e7eaa63d9a9bb259ce6b31992e9bbf04cf589c77f524a61cac93cbfa1482b5ad","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json deleted file mode 100644 index c92f1e79b..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json deleted file mode 100644 index 9a4655a55..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json deleted file mode 100644 index a96b99196..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json deleted file mode 100644 index 5399bff00..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json deleted file mode 100644 index 2dd8afd40..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json deleted file mode 100644 index da06cf2ad..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json deleted file mode 100644 index d93e4a959..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json deleted file mode 100644 index 8707fe829..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json deleted file mode 100644 index baf2caf4a..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json deleted file mode 100644 index 33e483060..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json deleted file mode 100644 index 15e5aabc0..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json deleted file mode 100644 index b3c9c8a14..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json deleted file mode 100644 index d56e72335..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json deleted file mode 100644 index e0d2bc69b..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json deleted file mode 100644 index 05288a509..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json deleted file mode 100644 index 8bb25e8d8..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json deleted file mode 100644 index 71b941d33..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json deleted file mode 100644 index 7af7cb482..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json deleted file mode 100644 index 4e747b722..000000000 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json similarity index 57% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json index 3c0296abd..c57e7510f 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json similarity index 55% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json index de44806ee..743d1fc97 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json new file mode 100644 index 000000000..91b63f911 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json similarity index 57% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json index ca59d5a4c..06b520126 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json similarity index 55% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json index 28653b2a8..5aaa6cab4 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json new file mode 100644 index 000000000..0a936ee87 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json similarity index 57% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json index 609def963..2752c77aa 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json similarity index 55% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json index 15e629d93..744c19efe 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json new file mode 100644 index 000000000..f69259edd --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json similarity index 57% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json index 40ea7e71f..1d59e9450 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json similarity index 55% rename from examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json rename to examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json index 128a88358..e6f5ec03e 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C49cf062e918bdc2f8a44a66473c4435e/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C49cf062e918bdc2f8a44a66473c4435e.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json new file mode 100644 index 000000000..77f4762f3 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json new file mode 100644 index 000000000..e064cadb1 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json new file mode 100644 index 000000000..975b0f67d --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json new file mode 100644 index 000000000..36ddd4e03 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json new file mode 100644 index 000000000..6fd708226 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json new file mode 100644 index 000000000..ff7551c33 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json new file mode 100644 index 000000000..b1ec4e88b --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json new file mode 100644 index 000000000..3ef288bb4 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json new file mode 100644 index 000000000..017884184 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json new file mode 100644 index 000000000..7fb2c45ed --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json new file mode 100644 index 000000000..c14c3dd26 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json new file mode 100644 index 000000000..595a07916 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json new file mode 100644 index 000000000..de3c6a8d8 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json new file mode 100644 index 000000000..1b95df4da --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json new file mode 100644 index 000000000..89c6710b7 --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json new file mode 100644 index 000000000..dd495c1dd --- /dev/null +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8.olean","$STAGING/preserve-src/LexLeanPreserve/C91b57d30cfd6f60128d6c72e374148ef/R8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C91b57d30cfd6f60128d6c72e374148ef.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/models/lexlean.lock b/examples/models/lexlean.lock index 15b28f70b..76dda7232 100644 --- a/examples/models/lexlean.lock +++ b/examples/models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production-coverage/expected/build/manifest.json b/examples/production-coverage/expected/build/manifest.json index 6c4268037..0a5ec6faa 100644 --- a/examples/production-coverage/expected/build/manifest.json +++ b/examples/production-coverage/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"59040522a70f7aa3631f88039de565ec405fdcabe1df421c362a0a9b23ebda1a","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"45eb63e8c0750ce4f1177cafea858eb1726ebc6f293343e70d11a07cf84f5529"},{"byte_length":739,"kind":"project-config","path":"lexlean.toml","sha256":"1bcbdf2b89a335e2e8685fb89b09d3c4eba9f30371947781755576f588df7434"},{"byte_length":1263,"kind":"source","path":"src/Boundary.lex.tex","sha256":"4675304c0db77f457ca6f558425c5ede68619a65dad4d6210e36f4765c10c222"},{"byte_length":4508,"kind":"source","path":"src/Colls.lex.tex","sha256":"af6d528bfe9c18c9abf2cf03e3bd3dfe6c5bc4808cf0d6e8dedd4faeca05e14e"},{"byte_length":3826,"kind":"source","path":"src/Main.lex.tex","sha256":"42698451ae141f4ea32a38f1e48e6337d30b06b108813e48c566b4d72e58acd6"},{"byte_length":4678,"kind":"source","path":"src/Prims.lex.tex","sha256":"c86661726922c5fadb430769d459ff5db7ec61c66d96386ef10001cd6079adfd"},{"byte_length":1333,"kind":"source","path":"src/RecRoots.lex.tex","sha256":"a10c554b3b0d752c4ae2aee4ae1d5c70c68eb2645fdd528caab1b4f5ceaf3502"},{"byte_length":10226,"kind":"source","path":"src/Recur.lex.tex","sha256":"a404c1ed64818f9b54d3bffeb9c1d5518460164acb9f6deecb54756fec3dabf3"},{"byte_length":861,"kind":"source","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"},{"byte_length":2571,"kind":"source","path":"src/Types.lex.tex","sha256":"80d360f45ad31fccc43a06831cc6137982c579a23f3de646be93d3c3ce59193a"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Coverage.Boundary","module":"Boundary","source_path":"src/Boundary.lex.tex"},{"lean_module":"Coverage.Colls","module":"Colls","source_path":"src/Colls.lex.tex"},{"lean_module":"Coverage.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Coverage.Prims","module":"Prims","source_path":"src/Prims.lex.tex"},{"lean_module":"Coverage.RecRoots","module":"RecRoots","source_path":"src/RecRoots.lex.tex"},{"lean_module":"Coverage.Recur","module":"Recur","source_path":"src/Recur.lex.tex"},{"lean_module":"Coverage.Syntax","module":"Syntax","source_path":"src/Syntax.lex.tex"},{"lean_module":"Coverage.Types","module":"Types","source_path":"src/Types.lex.tex"}],"outputs":[{"byte_length":7767,"kind":"coverage","path":"coverage/Coverage/Boundary.coverage.json","sha256":"c0e188dc71d64e8cf450f3ff2b635bef23fcbad299020c6fa930bbcf51612b7f"},{"byte_length":8998,"kind":"coverage","path":"coverage/Coverage/Colls.coverage.json","sha256":"a286e1aa4ad3f9891c2c783690fc5b565adc2ddbdadbded092b916e5480d415f"},{"byte_length":10376,"kind":"coverage","path":"coverage/Coverage/Main.coverage.json","sha256":"f2fb3a407f3972660ca5750b86ecd67ef51c83279f8bc8b820e62c2b3b880d40"},{"byte_length":8994,"kind":"coverage","path":"coverage/Coverage/Prims.coverage.json","sha256":"bf478753b3e28affdaac74ec00bc2c72c6121b003da67d9482c28f66f1b5412c"},{"byte_length":9030,"kind":"coverage","path":"coverage/Coverage/RecRoots.coverage.json","sha256":"13d817c2c2f255bcedd0b4bc549742daaa3565d4152a84919a31722821fc1bc6"},{"byte_length":14526,"kind":"coverage","path":"coverage/Coverage/Recur.coverage.json","sha256":"9cad30c1149b4f0591fb914334d4316762ae7429645395e40129fde4c7f753cc"},{"byte_length":7661,"kind":"coverage","path":"coverage/Coverage/Syntax.coverage.json","sha256":"a7e7aefd6a325b677497d3186bf0b4558bc092ff093e9d381b2caf6ae1d23432"},{"byte_length":10052,"kind":"coverage","path":"coverage/Coverage/Types.coverage.json","sha256":"c92a3b573ffb98f0378c0613504664a2712349e070fcba9a1967fe2301b96e4c"},{"byte_length":1138,"kind":"lean","path":"modules/Coverage/Boundary.lean","sha256":"af29aee16f61f7465e254ff167e6915bc8c267a1a1003aac3c69c0bf056ba275"},{"byte_length":4032,"kind":"lean","path":"modules/Coverage/Colls.lean","sha256":"61af86e818f34e6566625b62b20bb46c06b7ee09c4ffd102bfcc88ae2fd6f910"},{"byte_length":2739,"kind":"lean","path":"modules/Coverage/Main.lean","sha256":"afd4be513f508614189e0f8c69636a1a49094ecbae949f6373ff9838f90474f0"},{"byte_length":4457,"kind":"lean","path":"modules/Coverage/Prims.lean","sha256":"5cf6e5d468f72f5a61fb45722d19a62299b948de7e2055c483bca0d9a5d85e45"},{"byte_length":984,"kind":"lean","path":"modules/Coverage/RecRoots.lean","sha256":"5280da57d1865ec67a84af791b650a5fab86db12ea33895df2fb02c8f40256e7"},{"byte_length":33283,"kind":"lean","path":"modules/Coverage/Recur.lean","sha256":"25a70c53355965a4d29334138497abf19ea35b12afb9de949063c28b1c71cec5"},{"byte_length":620,"kind":"lean","path":"modules/Coverage/Syntax.lean","sha256":"0969465532980c30cabae6eeaa128080daffb6374d56878d461b98392470b379"},{"byte_length":1788,"kind":"lean","path":"modules/Coverage/Types.lean","sha256":"c6972ba54604d93590d5030bbb58503f0685e2968cdaad0a6e5cfcfe288574ec"},{"byte_length":10606,"kind":"lexicon-closure","path":"lexicons/Boundary.closure.json","sha256":"4e67900912cb73ae57443c035f462b0bf241b097ed8fd5bffb8996d593367f0a"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Colls.closure.json","sha256":"64b9cfce8348276765e03d03b5561282bc922e22dd0ce092ba295f8d7f9e27e3"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Prims.closure.json","sha256":"1ca8ce7adbd813b36a6bcbb61422b2e9606eba5108cc48f5723a76d5dd3133b0"},{"byte_length":10606,"kind":"lexicon-closure","path":"lexicons/RecRoots.closure.json","sha256":"b7929d5d112818efe69ec2210e1dac07a1907c35ae67b5963b5b0eb65ad0c086"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Recur.closure.json","sha256":"e5c73c5262bfb9bb40003c52f6a84431e06f4c9bf729d21993531c28702aa6a8"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Syntax.closure.json","sha256":"37a0e650d18d332b85cdcc97c6e3a86ffc1dbb591bace0b323fc8bf535336f8b"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Types.closure.json","sha256":"340585fd2c4c6277fb7214262beee52046db9b165cb6290c4b160f1e4ddc118c"},{"byte_length":2299,"kind":"map","path":"maps/Coverage/Boundary.map.json","sha256":"3351af73bea88e36c6c060482f4748807680683da898da3f2a3cb02ff4edc8e9"},{"byte_length":3916,"kind":"map","path":"maps/Coverage/Colls.map.json","sha256":"93d384549d720e6938b60fc656f4ec34e2bd1fac7700753bc2dd0290a58ee3d1"},{"byte_length":4862,"kind":"map","path":"maps/Coverage/Main.map.json","sha256":"47f8e59e895732299a823a6c46b36a5c07ae205daccb452e406b59815561fa29"},{"byte_length":3912,"kind":"map","path":"maps/Coverage/Prims.map.json","sha256":"8bd765bfd5183a2f0967a908c9df81b4692ed82a82fd17055797a6531a7cf0f1"},{"byte_length":2302,"kind":"map","path":"maps/Coverage/RecRoots.map.json","sha256":"d5bc84f46fa1551d48162cd17b447f56069dea4545ccfe31b2dc03f753380fbc"},{"byte_length":9764,"kind":"map","path":"maps/Coverage/Recur.map.json","sha256":"5c0e10baae5cdd9c28f0926d74c8fb619255db3a945a3e8ff924f8b4d9e290c4"},{"byte_length":2280,"kind":"map","path":"maps/Coverage/Syntax.map.json","sha256":"a38f5ad9890e7ee36b7ca41a1e3c3315461342e4d328c33748d19884eb421c63"},{"byte_length":5166,"kind":"map","path":"maps/Coverage/Types.map.json","sha256":"33812ff710fcaa5e8feb998643406fc8226d0c778b3cd05de4a672542be72bb0"},{"byte_length":5696,"kind":"production-eligibility","path":"production/Coverage/Boundary.eligibility.json","sha256":"e8ee809bef94b69b2257ee1cc20d9846c82f02bc3a3e9b910f69d31a99a8fda6"},{"byte_length":27395,"kind":"production-eligibility","path":"production/Coverage/Colls.eligibility.json","sha256":"8724ec83f26e3bb7f483666f87e14d65af6db7c33b9726d87275d4d79331a20e"},{"byte_length":28948,"kind":"production-eligibility","path":"production/Coverage/Main.eligibility.json","sha256":"6c43769b8becf4ecd39650c3d314511ee6a6c55cb24615c8762fbaa6f2a0f106"},{"byte_length":24889,"kind":"production-eligibility","path":"production/Coverage/Prims.eligibility.json","sha256":"cc1d1f204a4ba4dd523424d31c6c36b031d684a52dd8331949936ab6f87ac96f"},{"byte_length":16974,"kind":"production-eligibility","path":"production/Coverage/RecRoots.eligibility.json","sha256":"19c0640e04dba45dc72d1b0f69927950211bb6b1b92feb81dd2745636772ac62"},{"byte_length":1785,"kind":"tex","path":"modules/Coverage/Boundary.tex","sha256":"7f0b2f7721d8b64bc90af13abd4292d7e4cbdf5e19c38872c5bfe97c763d06f3"},{"byte_length":7518,"kind":"tex","path":"modules/Coverage/Colls.tex","sha256":"1223a4e7c19c2f79e28d56e614092f0f8c2506d0913a2079cd7e5372cb8b8da2"},{"byte_length":6930,"kind":"tex","path":"modules/Coverage/Main.tex","sha256":"08878a5bb3a95d296b6ad999d03a84a810d829a57f38fa91f5cba9c0fbd7e31b"},{"byte_length":7789,"kind":"tex","path":"modules/Coverage/Prims.tex","sha256":"73c1b19b794003957f3e0cf0328ee09251391330a2c6904fd7ae2f4b90ff1858"},{"byte_length":2358,"kind":"tex","path":"modules/Coverage/RecRoots.tex","sha256":"45877d577173fd6e145c67446677c60a1d3cecfa65550b3942d68183fe77a970"},{"byte_length":15320,"kind":"tex","path":"modules/Coverage/Recur.tex","sha256":"9b9efaf01a628d61547155fbf872a9fdec7ea34dac7444e9c5e62e63a42bfd06"},{"byte_length":1093,"kind":"tex","path":"modules/Coverage/Syntax.tex","sha256":"24391ae507ff036ad50cbece531289a033ddff326046c24e85c3968beb127bea"},{"byte_length":4199,"kind":"tex","path":"modules/Coverage/Types.tex","sha256":"e5e6325b5dcb5922332195c23875e4644b0491f4ccb69344ad9d75d860202b4e"}],"project":"production-coverage","selection":["Boundary","Colls","Main","Prims","RecRoots","Recur","Syntax","Types"],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","spec":"lexlean/build-manifest/1"} +{"build_id":"a46b31014101e773c5fee218d9b8cd2004428c64a523172f3c319bcd24a532f7","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"f7fc0aa65836d3f1305ff2d691f71b6ac284194204909905dd8394b12b866210"},{"byte_length":739,"kind":"project-config","path":"lexlean.toml","sha256":"1bcbdf2b89a335e2e8685fb89b09d3c4eba9f30371947781755576f588df7434"},{"byte_length":1263,"kind":"source","path":"src/Boundary.lex.tex","sha256":"4675304c0db77f457ca6f558425c5ede68619a65dad4d6210e36f4765c10c222"},{"byte_length":4508,"kind":"source","path":"src/Colls.lex.tex","sha256":"af6d528bfe9c18c9abf2cf03e3bd3dfe6c5bc4808cf0d6e8dedd4faeca05e14e"},{"byte_length":3826,"kind":"source","path":"src/Main.lex.tex","sha256":"42698451ae141f4ea32a38f1e48e6337d30b06b108813e48c566b4d72e58acd6"},{"byte_length":4678,"kind":"source","path":"src/Prims.lex.tex","sha256":"c86661726922c5fadb430769d459ff5db7ec61c66d96386ef10001cd6079adfd"},{"byte_length":1333,"kind":"source","path":"src/RecRoots.lex.tex","sha256":"a10c554b3b0d752c4ae2aee4ae1d5c70c68eb2645fdd528caab1b4f5ceaf3502"},{"byte_length":10226,"kind":"source","path":"src/Recur.lex.tex","sha256":"a404c1ed64818f9b54d3bffeb9c1d5518460164acb9f6deecb54756fec3dabf3"},{"byte_length":861,"kind":"source","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"},{"byte_length":2571,"kind":"source","path":"src/Types.lex.tex","sha256":"80d360f45ad31fccc43a06831cc6137982c579a23f3de646be93d3c3ce59193a"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Coverage.Boundary","module":"Boundary","source_path":"src/Boundary.lex.tex"},{"lean_module":"Coverage.Colls","module":"Colls","source_path":"src/Colls.lex.tex"},{"lean_module":"Coverage.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Coverage.Prims","module":"Prims","source_path":"src/Prims.lex.tex"},{"lean_module":"Coverage.RecRoots","module":"RecRoots","source_path":"src/RecRoots.lex.tex"},{"lean_module":"Coverage.Recur","module":"Recur","source_path":"src/Recur.lex.tex"},{"lean_module":"Coverage.Syntax","module":"Syntax","source_path":"src/Syntax.lex.tex"},{"lean_module":"Coverage.Types","module":"Types","source_path":"src/Types.lex.tex"}],"outputs":[{"byte_length":7767,"kind":"coverage","path":"coverage/Coverage/Boundary.coverage.json","sha256":"c0e188dc71d64e8cf450f3ff2b635bef23fcbad299020c6fa930bbcf51612b7f"},{"byte_length":8998,"kind":"coverage","path":"coverage/Coverage/Colls.coverage.json","sha256":"a286e1aa4ad3f9891c2c783690fc5b565adc2ddbdadbded092b916e5480d415f"},{"byte_length":10376,"kind":"coverage","path":"coverage/Coverage/Main.coverage.json","sha256":"f2fb3a407f3972660ca5750b86ecd67ef51c83279f8bc8b820e62c2b3b880d40"},{"byte_length":8994,"kind":"coverage","path":"coverage/Coverage/Prims.coverage.json","sha256":"bf478753b3e28affdaac74ec00bc2c72c6121b003da67d9482c28f66f1b5412c"},{"byte_length":9030,"kind":"coverage","path":"coverage/Coverage/RecRoots.coverage.json","sha256":"13d817c2c2f255bcedd0b4bc549742daaa3565d4152a84919a31722821fc1bc6"},{"byte_length":14526,"kind":"coverage","path":"coverage/Coverage/Recur.coverage.json","sha256":"9cad30c1149b4f0591fb914334d4316762ae7429645395e40129fde4c7f753cc"},{"byte_length":7661,"kind":"coverage","path":"coverage/Coverage/Syntax.coverage.json","sha256":"a7e7aefd6a325b677497d3186bf0b4558bc092ff093e9d381b2caf6ae1d23432"},{"byte_length":10052,"kind":"coverage","path":"coverage/Coverage/Types.coverage.json","sha256":"c92a3b573ffb98f0378c0613504664a2712349e070fcba9a1967fe2301b96e4c"},{"byte_length":1138,"kind":"lean","path":"modules/Coverage/Boundary.lean","sha256":"af29aee16f61f7465e254ff167e6915bc8c267a1a1003aac3c69c0bf056ba275"},{"byte_length":4032,"kind":"lean","path":"modules/Coverage/Colls.lean","sha256":"61af86e818f34e6566625b62b20bb46c06b7ee09c4ffd102bfcc88ae2fd6f910"},{"byte_length":2739,"kind":"lean","path":"modules/Coverage/Main.lean","sha256":"afd4be513f508614189e0f8c69636a1a49094ecbae949f6373ff9838f90474f0"},{"byte_length":4457,"kind":"lean","path":"modules/Coverage/Prims.lean","sha256":"5cf6e5d468f72f5a61fb45722d19a62299b948de7e2055c483bca0d9a5d85e45"},{"byte_length":984,"kind":"lean","path":"modules/Coverage/RecRoots.lean","sha256":"5280da57d1865ec67a84af791b650a5fab86db12ea33895df2fb02c8f40256e7"},{"byte_length":33283,"kind":"lean","path":"modules/Coverage/Recur.lean","sha256":"25a70c53355965a4d29334138497abf19ea35b12afb9de949063c28b1c71cec5"},{"byte_length":620,"kind":"lean","path":"modules/Coverage/Syntax.lean","sha256":"0969465532980c30cabae6eeaa128080daffb6374d56878d461b98392470b379"},{"byte_length":1788,"kind":"lean","path":"modules/Coverage/Types.lean","sha256":"c6972ba54604d93590d5030bbb58503f0685e2968cdaad0a6e5cfcfe288574ec"},{"byte_length":10606,"kind":"lexicon-closure","path":"lexicons/Boundary.closure.json","sha256":"4e67900912cb73ae57443c035f462b0bf241b097ed8fd5bffb8996d593367f0a"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Colls.closure.json","sha256":"64b9cfce8348276765e03d03b5561282bc922e22dd0ce092ba295f8d7f9e27e3"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Prims.closure.json","sha256":"1ca8ce7adbd813b36a6bcbb61422b2e9606eba5108cc48f5723a76d5dd3133b0"},{"byte_length":10606,"kind":"lexicon-closure","path":"lexicons/RecRoots.closure.json","sha256":"b7929d5d112818efe69ec2210e1dac07a1907c35ae67b5963b5b0eb65ad0c086"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Recur.closure.json","sha256":"e5c73c5262bfb9bb40003c52f6a84431e06f4c9bf729d21993531c28702aa6a8"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Syntax.closure.json","sha256":"37a0e650d18d332b85cdcc97c6e3a86ffc1dbb591bace0b323fc8bf535336f8b"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Types.closure.json","sha256":"340585fd2c4c6277fb7214262beee52046db9b165cb6290c4b160f1e4ddc118c"},{"byte_length":2299,"kind":"map","path":"maps/Coverage/Boundary.map.json","sha256":"f81307a9356a8d4c843feb69191b37ba689d5dafe15ca4e42d7f181cfd78d3d4"},{"byte_length":3916,"kind":"map","path":"maps/Coverage/Colls.map.json","sha256":"3affc2cb538b790e10921dd538d523abf6f704698e81317a451ce8dbe5f6634d"},{"byte_length":4862,"kind":"map","path":"maps/Coverage/Main.map.json","sha256":"38efa28d3103f990933fb3aaf14e798843e28fdf5fb205bb616a80bfb2aef02c"},{"byte_length":3912,"kind":"map","path":"maps/Coverage/Prims.map.json","sha256":"35c015d014d9d6b0a88d5dbedd1c981813d3eb783c56ad1812c331c4dc4bdb8a"},{"byte_length":2302,"kind":"map","path":"maps/Coverage/RecRoots.map.json","sha256":"e57ba3305ef341c7096e97532f1b665aa998a017647056c88c02f9ed730a58f6"},{"byte_length":9764,"kind":"map","path":"maps/Coverage/Recur.map.json","sha256":"eb04bbda80be2b586828c4e8767cb111601ed211bfea84781e6cf4790015d947"},{"byte_length":2280,"kind":"map","path":"maps/Coverage/Syntax.map.json","sha256":"b7753da01c67ad6fad5021fe41e11b1f2c3d1f69ca087a1d903de695c31ce65c"},{"byte_length":5166,"kind":"map","path":"maps/Coverage/Types.map.json","sha256":"d03a0ecafccd1a1e86c0f655665899f15d67bba48cc1db4098001dac5c468165"},{"byte_length":5696,"kind":"production-eligibility","path":"production/Coverage/Boundary.eligibility.json","sha256":"e8ee809bef94b69b2257ee1cc20d9846c82f02bc3a3e9b910f69d31a99a8fda6"},{"byte_length":27395,"kind":"production-eligibility","path":"production/Coverage/Colls.eligibility.json","sha256":"8724ec83f26e3bb7f483666f87e14d65af6db7c33b9726d87275d4d79331a20e"},{"byte_length":28948,"kind":"production-eligibility","path":"production/Coverage/Main.eligibility.json","sha256":"6c43769b8becf4ecd39650c3d314511ee6a6c55cb24615c8762fbaa6f2a0f106"},{"byte_length":24889,"kind":"production-eligibility","path":"production/Coverage/Prims.eligibility.json","sha256":"cc1d1f204a4ba4dd523424d31c6c36b031d684a52dd8331949936ab6f87ac96f"},{"byte_length":16974,"kind":"production-eligibility","path":"production/Coverage/RecRoots.eligibility.json","sha256":"19c0640e04dba45dc72d1b0f69927950211bb6b1b92feb81dd2745636772ac62"},{"byte_length":1785,"kind":"tex","path":"modules/Coverage/Boundary.tex","sha256":"7f0b2f7721d8b64bc90af13abd4292d7e4cbdf5e19c38872c5bfe97c763d06f3"},{"byte_length":7518,"kind":"tex","path":"modules/Coverage/Colls.tex","sha256":"1223a4e7c19c2f79e28d56e614092f0f8c2506d0913a2079cd7e5372cb8b8da2"},{"byte_length":6930,"kind":"tex","path":"modules/Coverage/Main.tex","sha256":"08878a5bb3a95d296b6ad999d03a84a810d829a57f38fa91f5cba9c0fbd7e31b"},{"byte_length":7789,"kind":"tex","path":"modules/Coverage/Prims.tex","sha256":"73c1b19b794003957f3e0cf0328ee09251391330a2c6904fd7ae2f4b90ff1858"},{"byte_length":2358,"kind":"tex","path":"modules/Coverage/RecRoots.tex","sha256":"45877d577173fd6e145c67446677c60a1d3cecfa65550b3942d68183fe77a970"},{"byte_length":15320,"kind":"tex","path":"modules/Coverage/Recur.tex","sha256":"9b9efaf01a628d61547155fbf872a9fdec7ea34dac7444e9c5e62e63a42bfd06"},{"byte_length":1093,"kind":"tex","path":"modules/Coverage/Syntax.tex","sha256":"24391ae507ff036ad50cbece531289a033ddff326046c24e85c3968beb127bea"},{"byte_length":4199,"kind":"tex","path":"modules/Coverage/Types.tex","sha256":"e5e6325b5dcb5922332195c23875e4644b0491f4ccb69344ad9d75d860202b4e"}],"project":"production-coverage","selection":["Boundary","Colls","Main","Prims","RecRoots","Recur","Syntax","Types"],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","spec":"lexlean/build-manifest/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Boundary.map.json b/examples/production-coverage/expected/build/maps/Coverage/Boundary.map.json index c72724f63..84cd47ce9 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Boundary.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Boundary.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Boundary.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Boundary.tex"}],"mappings":[{"artifact":0,"gen_end":279,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":0,"gen_end":520,"gen_start":279,"node":1,"role":"declaration","source":0,"src_end":427,"src_start":117},{"artifact":0,"gen_end":607,"gen_start":520,"node":2,"role":"declaration","source":0,"src_end":579,"src_start":429},{"artifact":0,"gen_end":838,"gen_start":607,"node":3,"role":"declaration","source":0,"src_end":865,"src_start":581},{"artifact":0,"gen_end":1115,"gen_start":838,"node":4,"role":"declaration","source":0,"src_end":1227,"src_start":867},{"artifact":0,"gen_end":1138,"gen_start":1115,"node":0,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":1,"gen_end":491,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":427,"src_start":117},{"artifact":1,"gen_end":681,"gen_start":491,"node":7,"role":"declaration","source":0,"src_end":579,"src_start":429},{"artifact":1,"gen_end":1164,"gen_start":681,"node":8,"role":"declaration","source":0,"src_end":865,"src_start":581},{"artifact":1,"gen_end":1770,"gen_start":1164,"node":9,"role":"declaration","source":0,"src_end":1227,"src_start":867},{"artifact":1,"gen_end":1785,"gen_start":1770,"node":5,"role":"declaration","source":0,"src_end":1263,"src_start":0}],"module":"Boundary","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Boundary.lex.tex","sha256":"4675304c0db77f457ca6f558425c5ede68619a65dad4d6210e36f4765c10c222"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Boundary.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Boundary.tex"}],"mappings":[{"artifact":0,"gen_end":279,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":0,"gen_end":520,"gen_start":279,"node":1,"role":"declaration","source":0,"src_end":427,"src_start":117},{"artifact":0,"gen_end":607,"gen_start":520,"node":2,"role":"declaration","source":0,"src_end":579,"src_start":429},{"artifact":0,"gen_end":838,"gen_start":607,"node":3,"role":"declaration","source":0,"src_end":865,"src_start":581},{"artifact":0,"gen_end":1115,"gen_start":838,"node":4,"role":"declaration","source":0,"src_end":1227,"src_start":867},{"artifact":0,"gen_end":1138,"gen_start":1115,"node":0,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":1263,"src_start":0},{"artifact":1,"gen_end":491,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":427,"src_start":117},{"artifact":1,"gen_end":681,"gen_start":491,"node":7,"role":"declaration","source":0,"src_end":579,"src_start":429},{"artifact":1,"gen_end":1164,"gen_start":681,"node":8,"role":"declaration","source":0,"src_end":865,"src_start":581},{"artifact":1,"gen_end":1770,"gen_start":1164,"node":9,"role":"declaration","source":0,"src_end":1227,"src_start":867},{"artifact":1,"gen_end":1785,"gen_start":1770,"node":5,"role":"declaration","source":0,"src_end":1263,"src_start":0}],"module":"Boundary","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Boundary.lex.tex","sha256":"4675304c0db77f457ca6f558425c5ede68619a65dad4d6210e36f4765c10c222"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Colls.map.json b/examples/production-coverage/expected/build/maps/Coverage/Colls.map.json index 42d34debd..61c1b6058 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Colls.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Colls.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Colls.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Colls.tex"}],"mappings":[{"artifact":0,"gen_end":276,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":0,"gen_end":1039,"gen_start":276,"node":1,"role":"declaration","source":0,"src_end":813,"src_start":114},{"artifact":0,"gen_end":1249,"gen_start":1039,"node":2,"role":"declaration","source":0,"src_end":1133,"src_start":815},{"artifact":0,"gen_end":1906,"gen_start":1249,"node":3,"role":"declaration","source":0,"src_end":1727,"src_start":1135},{"artifact":0,"gen_end":2202,"gen_start":1906,"node":4,"role":"declaration","source":0,"src_end":2094,"src_start":1729},{"artifact":0,"gen_end":2535,"gen_start":2202,"node":5,"role":"declaration","source":0,"src_end":2513,"src_start":2096},{"artifact":0,"gen_end":2877,"gen_start":2535,"node":6,"role":"declaration","source":0,"src_end":2929,"src_start":2515},{"artifact":0,"gen_end":3049,"gen_start":2877,"node":7,"role":"declaration","source":0,"src_end":3258,"src_start":2931},{"artifact":0,"gen_end":3725,"gen_start":3049,"node":8,"role":"declaration","source":0,"src_end":3965,"src_start":3260},{"artifact":0,"gen_end":4012,"gen_start":3725,"node":9,"role":"declaration","source":0,"src_end":4472,"src_start":3967},{"artifact":0,"gen_end":4032,"gen_start":4012,"node":0,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":1,"gen_end":1266,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":813,"src_start":114},{"artifact":1,"gen_end":1922,"gen_start":1266,"node":12,"role":"declaration","source":0,"src_end":1133,"src_start":815},{"artifact":1,"gen_end":2935,"gen_start":1922,"node":13,"role":"declaration","source":0,"src_end":1727,"src_start":1135},{"artifact":1,"gen_end":3738,"gen_start":2935,"node":14,"role":"declaration","source":0,"src_end":2094,"src_start":1729},{"artifact":1,"gen_end":4573,"gen_start":3738,"node":15,"role":"declaration","source":0,"src_end":2513,"src_start":2096},{"artifact":1,"gen_end":5281,"gen_start":4573,"node":16,"role":"declaration","source":0,"src_end":2929,"src_start":2515},{"artifact":1,"gen_end":5853,"gen_start":5281,"node":17,"role":"declaration","source":0,"src_end":3258,"src_start":2931},{"artifact":1,"gen_end":6888,"gen_start":5853,"node":18,"role":"declaration","source":0,"src_end":3965,"src_start":3260},{"artifact":1,"gen_end":7503,"gen_start":6888,"node":19,"role":"declaration","source":0,"src_end":4472,"src_start":3967},{"artifact":1,"gen_end":7518,"gen_start":7503,"node":10,"role":"declaration","source":0,"src_end":4508,"src_start":0}],"module":"Colls","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Colls.lex.tex","sha256":"af6d528bfe9c18c9abf2cf03e3bd3dfe6c5bc4808cf0d6e8dedd4faeca05e14e"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Colls.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Colls.tex"}],"mappings":[{"artifact":0,"gen_end":276,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":0,"gen_end":1039,"gen_start":276,"node":1,"role":"declaration","source":0,"src_end":813,"src_start":114},{"artifact":0,"gen_end":1249,"gen_start":1039,"node":2,"role":"declaration","source":0,"src_end":1133,"src_start":815},{"artifact":0,"gen_end":1906,"gen_start":1249,"node":3,"role":"declaration","source":0,"src_end":1727,"src_start":1135},{"artifact":0,"gen_end":2202,"gen_start":1906,"node":4,"role":"declaration","source":0,"src_end":2094,"src_start":1729},{"artifact":0,"gen_end":2535,"gen_start":2202,"node":5,"role":"declaration","source":0,"src_end":2513,"src_start":2096},{"artifact":0,"gen_end":2877,"gen_start":2535,"node":6,"role":"declaration","source":0,"src_end":2929,"src_start":2515},{"artifact":0,"gen_end":3049,"gen_start":2877,"node":7,"role":"declaration","source":0,"src_end":3258,"src_start":2931},{"artifact":0,"gen_end":3725,"gen_start":3049,"node":8,"role":"declaration","source":0,"src_end":3965,"src_start":3260},{"artifact":0,"gen_end":4012,"gen_start":3725,"node":9,"role":"declaration","source":0,"src_end":4472,"src_start":3967},{"artifact":0,"gen_end":4032,"gen_start":4012,"node":0,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":4508,"src_start":0},{"artifact":1,"gen_end":1266,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":813,"src_start":114},{"artifact":1,"gen_end":1922,"gen_start":1266,"node":12,"role":"declaration","source":0,"src_end":1133,"src_start":815},{"artifact":1,"gen_end":2935,"gen_start":1922,"node":13,"role":"declaration","source":0,"src_end":1727,"src_start":1135},{"artifact":1,"gen_end":3738,"gen_start":2935,"node":14,"role":"declaration","source":0,"src_end":2094,"src_start":1729},{"artifact":1,"gen_end":4573,"gen_start":3738,"node":15,"role":"declaration","source":0,"src_end":2513,"src_start":2096},{"artifact":1,"gen_end":5281,"gen_start":4573,"node":16,"role":"declaration","source":0,"src_end":2929,"src_start":2515},{"artifact":1,"gen_end":5853,"gen_start":5281,"node":17,"role":"declaration","source":0,"src_end":3258,"src_start":2931},{"artifact":1,"gen_end":6888,"gen_start":5853,"node":18,"role":"declaration","source":0,"src_end":3965,"src_start":3260},{"artifact":1,"gen_end":7503,"gen_start":6888,"node":19,"role":"declaration","source":0,"src_end":4472,"src_start":3967},{"artifact":1,"gen_end":7518,"gen_start":7503,"node":10,"role":"declaration","source":0,"src_end":4508,"src_start":0}],"module":"Colls","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Colls.lex.tex","sha256":"af6d528bfe9c18c9abf2cf03e3bd3dfe6c5bc4808cf0d6e8dedd4faeca05e14e"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Main.map.json b/examples/production-coverage/expected/build/maps/Coverage/Main.map.json index 220c56237..ec3857e50 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Main.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Main.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Main.tex"}],"mappings":[{"artifact":0,"gen_end":263,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":0,"gen_end":319,"gen_start":263,"node":1,"role":"declaration","source":0,"src_end":227,"src_start":134},{"artifact":0,"gen_end":670,"gen_start":319,"node":2,"role":"declaration","source":0,"src_end":614,"src_start":229},{"artifact":0,"gen_end":948,"gen_start":670,"node":3,"role":"declaration","source":0,"src_end":939,"src_start":616},{"artifact":0,"gen_end":1173,"gen_start":948,"node":4,"role":"declaration","source":0,"src_end":1250,"src_start":941},{"artifact":0,"gen_end":1390,"gen_start":1173,"node":5,"role":"declaration","source":0,"src_end":1574,"src_start":1252},{"artifact":0,"gen_end":1685,"gen_start":1390,"node":6,"role":"declaration","source":0,"src_end":2051,"src_start":1576},{"artifact":0,"gen_end":1909,"gen_start":1685,"node":7,"role":"declaration","source":0,"src_end":2398,"src_start":2053},{"artifact":0,"gen_end":2101,"gen_start":1909,"node":8,"role":"declaration","source":0,"src_end":2749,"src_start":2400},{"artifact":0,"gen_end":2195,"gen_start":2101,"node":9,"role":"declaration","source":0,"src_end":2950,"src_start":2751},{"artifact":0,"gen_end":2507,"gen_start":2195,"node":10,"role":"declaration","source":0,"src_end":3357,"src_start":2952},{"artifact":0,"gen_end":2646,"gen_start":2507,"node":11,"role":"declaration","source":0,"src_end":3603,"src_start":3359},{"artifact":0,"gen_end":2720,"gen_start":2646,"node":12,"role":"declaration","source":0,"src_end":3790,"src_start":3605},{"artifact":0,"gen_end":2739,"gen_start":2720,"node":0,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":1,"gen_end":437,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":227,"src_start":134},{"artifact":1,"gen_end":1146,"gen_start":437,"node":15,"role":"declaration","source":0,"src_end":614,"src_start":229},{"artifact":1,"gen_end":1780,"gen_start":1146,"node":16,"role":"declaration","source":0,"src_end":939,"src_start":616},{"artifact":1,"gen_end":2361,"gen_start":1780,"node":17,"role":"declaration","source":0,"src_end":1250,"src_start":941},{"artifact":1,"gen_end":2946,"gen_start":2361,"node":18,"role":"declaration","source":0,"src_end":1574,"src_start":1252},{"artifact":1,"gen_end":3601,"gen_start":2946,"node":19,"role":"declaration","source":0,"src_end":2051,"src_start":1576},{"artifact":1,"gen_end":4181,"gen_start":3601,"node":20,"role":"declaration","source":0,"src_end":2398,"src_start":2053},{"artifact":1,"gen_end":4729,"gen_start":4181,"node":21,"role":"declaration","source":0,"src_end":2749,"src_start":2400},{"artifact":1,"gen_end":5175,"gen_start":4729,"node":22,"role":"declaration","source":0,"src_end":2950,"src_start":2751},{"artifact":1,"gen_end":5987,"gen_start":5175,"node":23,"role":"declaration","source":0,"src_end":3357,"src_start":2952},{"artifact":1,"gen_end":6484,"gen_start":5987,"node":24,"role":"declaration","source":0,"src_end":3603,"src_start":3359},{"artifact":1,"gen_end":6915,"gen_start":6484,"node":25,"role":"declaration","source":0,"src_end":3790,"src_start":3605},{"artifact":1,"gen_end":6930,"gen_start":6915,"node":13,"role":"declaration","source":0,"src_end":3826,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"42698451ae141f4ea32a38f1e48e6337d30b06b108813e48c566b4d72e58acd6"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Main.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Main.tex"}],"mappings":[{"artifact":0,"gen_end":263,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":0,"gen_end":319,"gen_start":263,"node":1,"role":"declaration","source":0,"src_end":227,"src_start":134},{"artifact":0,"gen_end":670,"gen_start":319,"node":2,"role":"declaration","source":0,"src_end":614,"src_start":229},{"artifact":0,"gen_end":948,"gen_start":670,"node":3,"role":"declaration","source":0,"src_end":939,"src_start":616},{"artifact":0,"gen_end":1173,"gen_start":948,"node":4,"role":"declaration","source":0,"src_end":1250,"src_start":941},{"artifact":0,"gen_end":1390,"gen_start":1173,"node":5,"role":"declaration","source":0,"src_end":1574,"src_start":1252},{"artifact":0,"gen_end":1685,"gen_start":1390,"node":6,"role":"declaration","source":0,"src_end":2051,"src_start":1576},{"artifact":0,"gen_end":1909,"gen_start":1685,"node":7,"role":"declaration","source":0,"src_end":2398,"src_start":2053},{"artifact":0,"gen_end":2101,"gen_start":1909,"node":8,"role":"declaration","source":0,"src_end":2749,"src_start":2400},{"artifact":0,"gen_end":2195,"gen_start":2101,"node":9,"role":"declaration","source":0,"src_end":2950,"src_start":2751},{"artifact":0,"gen_end":2507,"gen_start":2195,"node":10,"role":"declaration","source":0,"src_end":3357,"src_start":2952},{"artifact":0,"gen_end":2646,"gen_start":2507,"node":11,"role":"declaration","source":0,"src_end":3603,"src_start":3359},{"artifact":0,"gen_end":2720,"gen_start":2646,"node":12,"role":"declaration","source":0,"src_end":3790,"src_start":3605},{"artifact":0,"gen_end":2739,"gen_start":2720,"node":0,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":13,"role":"declaration","source":0,"src_end":3826,"src_start":0},{"artifact":1,"gen_end":437,"gen_start":134,"node":14,"role":"declaration","source":0,"src_end":227,"src_start":134},{"artifact":1,"gen_end":1146,"gen_start":437,"node":15,"role":"declaration","source":0,"src_end":614,"src_start":229},{"artifact":1,"gen_end":1780,"gen_start":1146,"node":16,"role":"declaration","source":0,"src_end":939,"src_start":616},{"artifact":1,"gen_end":2361,"gen_start":1780,"node":17,"role":"declaration","source":0,"src_end":1250,"src_start":941},{"artifact":1,"gen_end":2946,"gen_start":2361,"node":18,"role":"declaration","source":0,"src_end":1574,"src_start":1252},{"artifact":1,"gen_end":3601,"gen_start":2946,"node":19,"role":"declaration","source":0,"src_end":2051,"src_start":1576},{"artifact":1,"gen_end":4181,"gen_start":3601,"node":20,"role":"declaration","source":0,"src_end":2398,"src_start":2053},{"artifact":1,"gen_end":4729,"gen_start":4181,"node":21,"role":"declaration","source":0,"src_end":2749,"src_start":2400},{"artifact":1,"gen_end":5175,"gen_start":4729,"node":22,"role":"declaration","source":0,"src_end":2950,"src_start":2751},{"artifact":1,"gen_end":5987,"gen_start":5175,"node":23,"role":"declaration","source":0,"src_end":3357,"src_start":2952},{"artifact":1,"gen_end":6484,"gen_start":5987,"node":24,"role":"declaration","source":0,"src_end":3603,"src_start":3359},{"artifact":1,"gen_end":6915,"gen_start":6484,"node":25,"role":"declaration","source":0,"src_end":3790,"src_start":3605},{"artifact":1,"gen_end":6930,"gen_start":6915,"node":13,"role":"declaration","source":0,"src_end":3826,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-latex-module"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"42698451ae141f4ea32a38f1e48e6337d30b06b108813e48c566b4d72e58acd6"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Prims.map.json b/examples/production-coverage/expected/build/maps/Coverage/Prims.map.json index 0de7f1f39..b3fcfe0fd 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Prims.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Prims.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Prims.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Prims.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":0,"gen_end":695,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":625,"src_start":114},{"artifact":0,"gen_end":1073,"gen_start":695,"node":2,"role":"declaration","source":0,"src_end":1075,"src_start":627},{"artifact":0,"gen_end":1677,"gen_start":1073,"node":3,"role":"declaration","source":0,"src_end":1686,"src_start":1077},{"artifact":0,"gen_end":2212,"gen_start":1677,"node":4,"role":"declaration","source":0,"src_end":2232,"src_start":1688},{"artifact":0,"gen_end":2424,"gen_start":2212,"node":5,"role":"declaration","source":0,"src_end":2559,"src_start":2234},{"artifact":0,"gen_end":3261,"gen_start":2424,"node":6,"role":"declaration","source":0,"src_end":3251,"src_start":2561},{"artifact":0,"gen_end":3454,"gen_start":3261,"node":7,"role":"declaration","source":0,"src_end":3587,"src_start":3253},{"artifact":0,"gen_end":3626,"gen_start":3454,"node":8,"role":"declaration","source":0,"src_end":3891,"src_start":3589},{"artifact":0,"gen_end":4437,"gen_start":3626,"node":9,"role":"declaration","source":0,"src_end":4642,"src_start":3893},{"artifact":0,"gen_end":4457,"gen_start":4437,"node":0,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":1,"gen_end":969,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":625,"src_start":114},{"artifact":1,"gen_end":1722,"gen_start":969,"node":12,"role":"declaration","source":0,"src_end":1075,"src_start":627},{"artifact":1,"gen_end":2701,"gen_start":1722,"node":13,"role":"declaration","source":0,"src_end":1686,"src_start":1077},{"artifact":1,"gen_end":3611,"gen_start":2701,"node":14,"role":"declaration","source":0,"src_end":2232,"src_start":1688},{"artifact":1,"gen_end":4198,"gen_start":3611,"node":15,"role":"declaration","source":0,"src_end":2559,"src_start":2234},{"artifact":1,"gen_end":5394,"gen_start":4198,"node":16,"role":"declaration","source":0,"src_end":3251,"src_start":2561},{"artifact":1,"gen_end":5985,"gen_start":5394,"node":17,"role":"declaration","source":0,"src_end":3587,"src_start":3253},{"artifact":1,"gen_end":6545,"gen_start":5985,"node":18,"role":"declaration","source":0,"src_end":3891,"src_start":3589},{"artifact":1,"gen_end":7774,"gen_start":6545,"node":19,"role":"declaration","source":0,"src_end":4642,"src_start":3893},{"artifact":1,"gen_end":7789,"gen_start":7774,"node":10,"role":"declaration","source":0,"src_end":4678,"src_start":0}],"module":"Prims","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Prims.lex.tex","sha256":"c86661726922c5fadb430769d459ff5db7ec61c66d96386ef10001cd6079adfd"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Prims.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Prims.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":0,"gen_end":695,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":625,"src_start":114},{"artifact":0,"gen_end":1073,"gen_start":695,"node":2,"role":"declaration","source":0,"src_end":1075,"src_start":627},{"artifact":0,"gen_end":1677,"gen_start":1073,"node":3,"role":"declaration","source":0,"src_end":1686,"src_start":1077},{"artifact":0,"gen_end":2212,"gen_start":1677,"node":4,"role":"declaration","source":0,"src_end":2232,"src_start":1688},{"artifact":0,"gen_end":2424,"gen_start":2212,"node":5,"role":"declaration","source":0,"src_end":2559,"src_start":2234},{"artifact":0,"gen_end":3261,"gen_start":2424,"node":6,"role":"declaration","source":0,"src_end":3251,"src_start":2561},{"artifact":0,"gen_end":3454,"gen_start":3261,"node":7,"role":"declaration","source":0,"src_end":3587,"src_start":3253},{"artifact":0,"gen_end":3626,"gen_start":3454,"node":8,"role":"declaration","source":0,"src_end":3891,"src_start":3589},{"artifact":0,"gen_end":4437,"gen_start":3626,"node":9,"role":"declaration","source":0,"src_end":4642,"src_start":3893},{"artifact":0,"gen_end":4457,"gen_start":4437,"node":0,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":4678,"src_start":0},{"artifact":1,"gen_end":969,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":625,"src_start":114},{"artifact":1,"gen_end":1722,"gen_start":969,"node":12,"role":"declaration","source":0,"src_end":1075,"src_start":627},{"artifact":1,"gen_end":2701,"gen_start":1722,"node":13,"role":"declaration","source":0,"src_end":1686,"src_start":1077},{"artifact":1,"gen_end":3611,"gen_start":2701,"node":14,"role":"declaration","source":0,"src_end":2232,"src_start":1688},{"artifact":1,"gen_end":4198,"gen_start":3611,"node":15,"role":"declaration","source":0,"src_end":2559,"src_start":2234},{"artifact":1,"gen_end":5394,"gen_start":4198,"node":16,"role":"declaration","source":0,"src_end":3251,"src_start":2561},{"artifact":1,"gen_end":5985,"gen_start":5394,"node":17,"role":"declaration","source":0,"src_end":3587,"src_start":3253},{"artifact":1,"gen_end":6545,"gen_start":5985,"node":18,"role":"declaration","source":0,"src_end":3891,"src_start":3589},{"artifact":1,"gen_end":7774,"gen_start":6545,"node":19,"role":"declaration","source":0,"src_end":4642,"src_start":3893},{"artifact":1,"gen_end":7789,"gen_start":7774,"node":10,"role":"declaration","source":0,"src_end":4678,"src_start":0}],"module":"Prims","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Prims.lex.tex","sha256":"c86661726922c5fadb430769d459ff5db7ec61c66d96386ef10001cd6079adfd"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/RecRoots.map.json b/examples/production-coverage/expected/build/maps/Coverage/RecRoots.map.json index 63a6f6373..9ac0f98e6 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/RecRoots.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/RecRoots.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/RecRoots.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/RecRoots.tex"}],"mappings":[{"artifact":0,"gen_end":259,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":0,"gen_end":493,"gen_start":259,"node":1,"role":"declaration","source":0,"src_end":488,"src_start":160},{"artifact":0,"gen_end":591,"gen_start":493,"node":2,"role":"declaration","source":0,"src_end":702,"src_start":490},{"artifact":0,"gen_end":787,"gen_start":591,"node":3,"role":"declaration","source":0,"src_end":1015,"src_start":704},{"artifact":0,"gen_end":961,"gen_start":787,"node":4,"role":"declaration","source":0,"src_end":1297,"src_start":1017},{"artifact":0,"gen_end":984,"gen_start":961,"node":0,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":1,"gen_end":736,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":488,"src_start":160},{"artifact":1,"gen_end":1202,"gen_start":736,"node":7,"role":"declaration","source":0,"src_end":702,"src_start":490},{"artifact":1,"gen_end":1788,"gen_start":1202,"node":8,"role":"declaration","source":0,"src_end":1015,"src_start":704},{"artifact":1,"gen_end":2343,"gen_start":1788,"node":9,"role":"declaration","source":0,"src_end":1297,"src_start":1017},{"artifact":1,"gen_end":2358,"gen_start":2343,"node":5,"role":"declaration","source":0,"src_end":1333,"src_start":0}],"module":"RecRoots","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/RecRoots.lex.tex","sha256":"a10c554b3b0d752c4ae2aee4ae1d5c70c68eb2645fdd528caab1b4f5ceaf3502"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/RecRoots.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/RecRoots.tex"}],"mappings":[{"artifact":0,"gen_end":259,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":0,"gen_end":493,"gen_start":259,"node":1,"role":"declaration","source":0,"src_end":488,"src_start":160},{"artifact":0,"gen_end":591,"gen_start":493,"node":2,"role":"declaration","source":0,"src_end":702,"src_start":490},{"artifact":0,"gen_end":787,"gen_start":591,"node":3,"role":"declaration","source":0,"src_end":1015,"src_start":704},{"artifact":0,"gen_end":961,"gen_start":787,"node":4,"role":"declaration","source":0,"src_end":1297,"src_start":1017},{"artifact":0,"gen_end":984,"gen_start":961,"node":0,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":1333,"src_start":0},{"artifact":1,"gen_end":736,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":488,"src_start":160},{"artifact":1,"gen_end":1202,"gen_start":736,"node":7,"role":"declaration","source":0,"src_end":702,"src_start":490},{"artifact":1,"gen_end":1788,"gen_start":1202,"node":8,"role":"declaration","source":0,"src_end":1015,"src_start":704},{"artifact":1,"gen_end":2343,"gen_start":1788,"node":9,"role":"declaration","source":0,"src_end":1297,"src_start":1017},{"artifact":1,"gen_end":2358,"gen_start":2343,"node":5,"role":"declaration","source":0,"src_end":1333,"src_start":0}],"module":"RecRoots","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/RecRoots.lex.tex","sha256":"a10c554b3b0d752c4ae2aee4ae1d5c70c68eb2645fdd528caab1b4f5ceaf3502"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Recur.map.json b/examples/production-coverage/expected/build/maps/Coverage/Recur.map.json index 70c1fcb18..ca0422115 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Recur.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Recur.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Recur.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Recur.tex"}],"mappings":[{"artifact":0,"gen_end":299,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":0,"gen_end":515,"gen_start":299,"node":1,"role":"declaration","source":0,"src_end":417,"src_start":136},{"artifact":0,"gen_end":761,"gen_start":515,"node":2,"role":"declaration","source":0,"src_end":744,"src_start":419},{"artifact":0,"gen_end":1124,"gen_start":761,"node":3,"role":"declaration","source":0,"src_end":1153,"src_start":746},{"artifact":0,"gen_end":1356,"gen_start":1124,"node":4,"role":"declaration","source":0,"src_end":1456,"src_start":1155},{"artifact":0,"gen_end":1654,"gen_start":1356,"node":5,"role":"declaration","source":0,"src_end":1970,"src_start":1458},{"artifact":0,"gen_end":1821,"gen_start":1654,"node":6,"role":"declaration","source":0,"src_end":2197,"src_start":1972},{"artifact":0,"gen_end":1986,"gen_start":1821,"node":7,"role":"declaration","source":0,"src_end":2425,"src_start":2199},{"artifact":0,"gen_end":5069,"gen_start":1986,"node":8,"role":"declaration","source":0,"src_end":2656,"src_start":2427},{"artifact":0,"gen_end":5482,"gen_start":5069,"node":9,"role":"declaration","source":0,"src_end":2966,"src_start":2658},{"artifact":0,"gen_end":8602,"gen_start":5482,"node":10,"role":"declaration","source":0,"src_end":3226,"src_start":2968},{"artifact":0,"gen_end":9117,"gen_start":8602,"node":11,"role":"declaration","source":0,"src_end":3559,"src_start":3228},{"artifact":0,"gen_end":12298,"gen_start":9117,"node":12,"role":"declaration","source":0,"src_end":3866,"src_start":3561},{"artifact":0,"gen_end":12845,"gen_start":12298,"node":13,"role":"declaration","source":0,"src_end":4223,"src_start":3868},{"artifact":0,"gen_end":13054,"gen_start":12845,"node":14,"role":"declaration","source":0,"src_end":4508,"src_start":4225},{"artifact":0,"gen_end":16278,"gen_start":13054,"node":15,"role":"declaration","source":0,"src_end":4870,"src_start":4510},{"artifact":0,"gen_end":19621,"gen_start":16278,"node":16,"role":"declaration","source":0,"src_end":5346,"src_start":4872},{"artifact":0,"gen_end":20503,"gen_start":19621,"node":17,"role":"declaration","source":0,"src_end":5968,"src_start":5348},{"artifact":0,"gen_end":23805,"gen_start":20503,"node":18,"role":"declaration","source":0,"src_end":6408,"src_start":5970},{"artifact":0,"gen_end":24554,"gen_start":23805,"node":19,"role":"declaration","source":0,"src_end":6917,"src_start":6410},{"artifact":0,"gen_end":25627,"gen_start":24554,"node":20,"role":"declaration","source":0,"src_end":8040,"src_start":6919},{"artifact":0,"gen_end":25917,"gen_start":25627,"node":21,"role":"declaration","source":0,"src_end":8376,"src_start":8042},{"artifact":0,"gen_end":26300,"gen_start":25917,"node":22,"role":"declaration","source":0,"src_end":9001,"src_start":8378},{"artifact":0,"gen_end":29351,"gen_start":26300,"node":23,"role":"declaration","source":0,"src_end":9216,"src_start":9003},{"artifact":0,"gen_end":32478,"gen_start":29351,"node":24,"role":"declaration","source":0,"src_end":9479,"src_start":9218},{"artifact":0,"gen_end":32826,"gen_start":32478,"node":25,"role":"declaration","source":0,"src_end":9760,"src_start":9481},{"artifact":0,"gen_end":33203,"gen_start":32826,"node":26,"role":"declaration","source":0,"src_end":10059,"src_start":9762},{"artifact":0,"gen_end":33263,"gen_start":33203,"node":27,"role":"declaration","source":0,"src_end":10190,"src_start":10061},{"artifact":0,"gen_end":33283,"gen_start":33263,"node":0,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":28,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":1,"gen_end":687,"gen_start":134,"node":29,"role":"declaration","source":0,"src_end":417,"src_start":136},{"artifact":1,"gen_end":1270,"gen_start":687,"node":30,"role":"declaration","source":0,"src_end":744,"src_start":419},{"artifact":1,"gen_end":1934,"gen_start":1270,"node":31,"role":"declaration","source":0,"src_end":1153,"src_start":746},{"artifact":1,"gen_end":2475,"gen_start":1934,"node":32,"role":"declaration","source":0,"src_end":1456,"src_start":1155},{"artifact":1,"gen_end":3079,"gen_start":2475,"node":33,"role":"declaration","source":0,"src_end":1970,"src_start":1458},{"artifact":1,"gen_end":3544,"gen_start":3079,"node":34,"role":"declaration","source":0,"src_end":2197,"src_start":1972},{"artifact":1,"gen_end":4010,"gen_start":3544,"node":35,"role":"declaration","source":0,"src_end":2425,"src_start":2199},{"artifact":1,"gen_end":4352,"gen_start":4010,"node":36,"role":"declaration","source":0,"src_end":2656,"src_start":2427},{"artifact":1,"gen_end":4919,"gen_start":4352,"node":37,"role":"declaration","source":0,"src_end":2966,"src_start":2658},{"artifact":1,"gen_end":5299,"gen_start":4919,"node":38,"role":"declaration","source":0,"src_end":3226,"src_start":2968},{"artifact":1,"gen_end":5898,"gen_start":5299,"node":39,"role":"declaration","source":0,"src_end":3559,"src_start":3228},{"artifact":1,"gen_end":6339,"gen_start":5898,"node":40,"role":"declaration","source":0,"src_end":3866,"src_start":3561},{"artifact":1,"gen_end":6964,"gen_start":6339,"node":41,"role":"declaration","source":0,"src_end":4223,"src_start":3868},{"artifact":1,"gen_end":7435,"gen_start":6964,"node":42,"role":"declaration","source":0,"src_end":4508,"src_start":4225},{"artifact":1,"gen_end":7898,"gen_start":7435,"node":43,"role":"declaration","source":0,"src_end":4870,"src_start":4510},{"artifact":1,"gen_end":8480,"gen_start":7898,"node":44,"role":"declaration","source":0,"src_end":5346,"src_start":4872},{"artifact":1,"gen_end":9393,"gen_start":8480,"node":45,"role":"declaration","source":0,"src_end":5968,"src_start":5348},{"artifact":1,"gen_end":9934,"gen_start":9393,"node":46,"role":"declaration","source":0,"src_end":6408,"src_start":5970},{"artifact":1,"gen_end":10716,"gen_start":9934,"node":47,"role":"declaration","source":0,"src_end":6917,"src_start":6410},{"artifact":1,"gen_end":12094,"gen_start":10716,"node":48,"role":"declaration","source":0,"src_end":8040,"src_start":6919},{"artifact":1,"gen_end":12690,"gen_start":12094,"node":49,"role":"declaration","source":0,"src_end":8376,"src_start":8042},{"artifact":1,"gen_end":13375,"gen_start":12690,"node":50,"role":"declaration","source":0,"src_end":9001,"src_start":8378},{"artifact":1,"gen_end":13687,"gen_start":13375,"node":51,"role":"declaration","source":0,"src_end":9216,"src_start":9003},{"artifact":1,"gen_end":14075,"gen_start":13687,"node":52,"role":"declaration","source":0,"src_end":9479,"src_start":9218},{"artifact":1,"gen_end":14579,"gen_start":14075,"node":53,"role":"declaration","source":0,"src_end":9760,"src_start":9481},{"artifact":1,"gen_end":15115,"gen_start":14579,"node":54,"role":"declaration","source":0,"src_end":10059,"src_start":9762},{"artifact":1,"gen_end":15305,"gen_start":15115,"node":55,"role":"declaration","source":0,"src_end":10190,"src_start":10061},{"artifact":1,"gen_end":15320,"gen_start":15305,"node":28,"role":"declaration","source":0,"src_end":10226,"src_start":0}],"module":"Recur","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-latex-module"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Recur.lex.tex","sha256":"a404c1ed64818f9b54d3bffeb9c1d5518460164acb9f6deecb54756fec3dabf3"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Recur.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Recur.tex"}],"mappings":[{"artifact":0,"gen_end":299,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":0,"gen_end":515,"gen_start":299,"node":1,"role":"declaration","source":0,"src_end":417,"src_start":136},{"artifact":0,"gen_end":761,"gen_start":515,"node":2,"role":"declaration","source":0,"src_end":744,"src_start":419},{"artifact":0,"gen_end":1124,"gen_start":761,"node":3,"role":"declaration","source":0,"src_end":1153,"src_start":746},{"artifact":0,"gen_end":1356,"gen_start":1124,"node":4,"role":"declaration","source":0,"src_end":1456,"src_start":1155},{"artifact":0,"gen_end":1654,"gen_start":1356,"node":5,"role":"declaration","source":0,"src_end":1970,"src_start":1458},{"artifact":0,"gen_end":1821,"gen_start":1654,"node":6,"role":"declaration","source":0,"src_end":2197,"src_start":1972},{"artifact":0,"gen_end":1986,"gen_start":1821,"node":7,"role":"declaration","source":0,"src_end":2425,"src_start":2199},{"artifact":0,"gen_end":5069,"gen_start":1986,"node":8,"role":"declaration","source":0,"src_end":2656,"src_start":2427},{"artifact":0,"gen_end":5482,"gen_start":5069,"node":9,"role":"declaration","source":0,"src_end":2966,"src_start":2658},{"artifact":0,"gen_end":8602,"gen_start":5482,"node":10,"role":"declaration","source":0,"src_end":3226,"src_start":2968},{"artifact":0,"gen_end":9117,"gen_start":8602,"node":11,"role":"declaration","source":0,"src_end":3559,"src_start":3228},{"artifact":0,"gen_end":12298,"gen_start":9117,"node":12,"role":"declaration","source":0,"src_end":3866,"src_start":3561},{"artifact":0,"gen_end":12845,"gen_start":12298,"node":13,"role":"declaration","source":0,"src_end":4223,"src_start":3868},{"artifact":0,"gen_end":13054,"gen_start":12845,"node":14,"role":"declaration","source":0,"src_end":4508,"src_start":4225},{"artifact":0,"gen_end":16278,"gen_start":13054,"node":15,"role":"declaration","source":0,"src_end":4870,"src_start":4510},{"artifact":0,"gen_end":19621,"gen_start":16278,"node":16,"role":"declaration","source":0,"src_end":5346,"src_start":4872},{"artifact":0,"gen_end":20503,"gen_start":19621,"node":17,"role":"declaration","source":0,"src_end":5968,"src_start":5348},{"artifact":0,"gen_end":23805,"gen_start":20503,"node":18,"role":"declaration","source":0,"src_end":6408,"src_start":5970},{"artifact":0,"gen_end":24554,"gen_start":23805,"node":19,"role":"declaration","source":0,"src_end":6917,"src_start":6410},{"artifact":0,"gen_end":25627,"gen_start":24554,"node":20,"role":"declaration","source":0,"src_end":8040,"src_start":6919},{"artifact":0,"gen_end":25917,"gen_start":25627,"node":21,"role":"declaration","source":0,"src_end":8376,"src_start":8042},{"artifact":0,"gen_end":26300,"gen_start":25917,"node":22,"role":"declaration","source":0,"src_end":9001,"src_start":8378},{"artifact":0,"gen_end":29351,"gen_start":26300,"node":23,"role":"declaration","source":0,"src_end":9216,"src_start":9003},{"artifact":0,"gen_end":32478,"gen_start":29351,"node":24,"role":"declaration","source":0,"src_end":9479,"src_start":9218},{"artifact":0,"gen_end":32826,"gen_start":32478,"node":25,"role":"declaration","source":0,"src_end":9760,"src_start":9481},{"artifact":0,"gen_end":33203,"gen_start":32826,"node":26,"role":"declaration","source":0,"src_end":10059,"src_start":9762},{"artifact":0,"gen_end":33263,"gen_start":33203,"node":27,"role":"declaration","source":0,"src_end":10190,"src_start":10061},{"artifact":0,"gen_end":33283,"gen_start":33263,"node":0,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":28,"role":"declaration","source":0,"src_end":10226,"src_start":0},{"artifact":1,"gen_end":687,"gen_start":134,"node":29,"role":"declaration","source":0,"src_end":417,"src_start":136},{"artifact":1,"gen_end":1270,"gen_start":687,"node":30,"role":"declaration","source":0,"src_end":744,"src_start":419},{"artifact":1,"gen_end":1934,"gen_start":1270,"node":31,"role":"declaration","source":0,"src_end":1153,"src_start":746},{"artifact":1,"gen_end":2475,"gen_start":1934,"node":32,"role":"declaration","source":0,"src_end":1456,"src_start":1155},{"artifact":1,"gen_end":3079,"gen_start":2475,"node":33,"role":"declaration","source":0,"src_end":1970,"src_start":1458},{"artifact":1,"gen_end":3544,"gen_start":3079,"node":34,"role":"declaration","source":0,"src_end":2197,"src_start":1972},{"artifact":1,"gen_end":4010,"gen_start":3544,"node":35,"role":"declaration","source":0,"src_end":2425,"src_start":2199},{"artifact":1,"gen_end":4352,"gen_start":4010,"node":36,"role":"declaration","source":0,"src_end":2656,"src_start":2427},{"artifact":1,"gen_end":4919,"gen_start":4352,"node":37,"role":"declaration","source":0,"src_end":2966,"src_start":2658},{"artifact":1,"gen_end":5299,"gen_start":4919,"node":38,"role":"declaration","source":0,"src_end":3226,"src_start":2968},{"artifact":1,"gen_end":5898,"gen_start":5299,"node":39,"role":"declaration","source":0,"src_end":3559,"src_start":3228},{"artifact":1,"gen_end":6339,"gen_start":5898,"node":40,"role":"declaration","source":0,"src_end":3866,"src_start":3561},{"artifact":1,"gen_end":6964,"gen_start":6339,"node":41,"role":"declaration","source":0,"src_end":4223,"src_start":3868},{"artifact":1,"gen_end":7435,"gen_start":6964,"node":42,"role":"declaration","source":0,"src_end":4508,"src_start":4225},{"artifact":1,"gen_end":7898,"gen_start":7435,"node":43,"role":"declaration","source":0,"src_end":4870,"src_start":4510},{"artifact":1,"gen_end":8480,"gen_start":7898,"node":44,"role":"declaration","source":0,"src_end":5346,"src_start":4872},{"artifact":1,"gen_end":9393,"gen_start":8480,"node":45,"role":"declaration","source":0,"src_end":5968,"src_start":5348},{"artifact":1,"gen_end":9934,"gen_start":9393,"node":46,"role":"declaration","source":0,"src_end":6408,"src_start":5970},{"artifact":1,"gen_end":10716,"gen_start":9934,"node":47,"role":"declaration","source":0,"src_end":6917,"src_start":6410},{"artifact":1,"gen_end":12094,"gen_start":10716,"node":48,"role":"declaration","source":0,"src_end":8040,"src_start":6919},{"artifact":1,"gen_end":12690,"gen_start":12094,"node":49,"role":"declaration","source":0,"src_end":8376,"src_start":8042},{"artifact":1,"gen_end":13375,"gen_start":12690,"node":50,"role":"declaration","source":0,"src_end":9001,"src_start":8378},{"artifact":1,"gen_end":13687,"gen_start":13375,"node":51,"role":"declaration","source":0,"src_end":9216,"src_start":9003},{"artifact":1,"gen_end":14075,"gen_start":13687,"node":52,"role":"declaration","source":0,"src_end":9479,"src_start":9218},{"artifact":1,"gen_end":14579,"gen_start":14075,"node":53,"role":"declaration","source":0,"src_end":9760,"src_start":9481},{"artifact":1,"gen_end":15115,"gen_start":14579,"node":54,"role":"declaration","source":0,"src_end":10059,"src_start":9762},{"artifact":1,"gen_end":15305,"gen_start":15115,"node":55,"role":"declaration","source":0,"src_end":10190,"src_start":10061},{"artifact":1,"gen_end":15320,"gen_start":15305,"node":28,"role":"declaration","source":0,"src_end":10226,"src_start":0}],"module":"Recur","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-latex-module"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Recur.lex.tex","sha256":"a404c1ed64818f9b54d3bffeb9c1d5518460164acb9f6deecb54756fec3dabf3"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Syntax.map.json b/examples/production-coverage/expected/build/maps/Coverage/Syntax.map.json index 536cf9032..a5d74f8c0 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Syntax.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Syntax.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Syntax.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Syntax.tex"}],"mappings":[{"artifact":0,"gen_end":198,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":0,"gen_end":286,"gen_start":198,"node":1,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":0,"gen_end":414,"gen_start":286,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":0,"gen_end":517,"gen_start":414,"node":3,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":0,"gen_end":599,"gen_start":517,"node":4,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":0,"gen_end":620,"gen_start":599,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":328,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":1,"gen_end":637,"gen_start":328,"node":7,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":1,"gen_end":886,"gen_start":637,"node":8,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":1,"gen_end":1078,"gen_start":886,"node":9,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":1,"gen_end":1093,"gen_start":1078,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0}],"module":"Syntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Syntax.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Syntax.tex"}],"mappings":[{"artifact":0,"gen_end":198,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":0,"gen_end":286,"gen_start":198,"node":1,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":0,"gen_end":414,"gen_start":286,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":0,"gen_end":517,"gen_start":414,"node":3,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":0,"gen_end":599,"gen_start":517,"node":4,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":0,"gen_end":620,"gen_start":599,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":328,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":1,"gen_end":637,"gen_start":328,"node":7,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":1,"gen_end":886,"gen_start":637,"node":8,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":1,"gen_end":1078,"gen_start":886,"node":9,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":1,"gen_end":1093,"gen_start":1078,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0}],"module":"Syntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/build/maps/Coverage/Types.map.json b/examples/production-coverage/expected/build/maps/Coverage/Types.map.json index 121044b93..230f21ecb 100644 --- a/examples/production-coverage/expected/build/maps/Coverage/Types.map.json +++ b/examples/production-coverage/expected/build/maps/Coverage/Types.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Types.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Types.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":0,"gen_end":325,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":307,"src_start":114},{"artifact":0,"gen_end":404,"gen_start":325,"node":2,"role":"declaration","source":0,"src_end":460,"src_start":309},{"artifact":0,"gen_end":454,"gen_start":404,"node":3,"role":"declaration","source":0,"src_end":585,"src_start":462},{"artifact":0,"gen_end":527,"gen_start":454,"node":4,"role":"declaration","source":0,"src_end":724,"src_start":587},{"artifact":0,"gen_end":582,"gen_start":527,"node":5,"role":"declaration","source":0,"src_end":854,"src_start":726},{"artifact":0,"gen_end":674,"gen_start":582,"node":6,"role":"declaration","source":0,"src_end":1006,"src_start":856},{"artifact":0,"gen_end":922,"gen_start":674,"node":7,"role":"declaration","source":0,"src_end":1270,"src_start":1008},{"artifact":0,"gen_end":1051,"gen_start":922,"node":8,"role":"declaration","source":0,"src_end":1487,"src_start":1272},{"artifact":0,"gen_end":1136,"gen_start":1051,"node":9,"role":"declaration","source":0,"src_end":1646,"src_start":1489},{"artifact":0,"gen_end":1237,"gen_start":1136,"node":10,"role":"declaration","source":0,"src_end":1803,"src_start":1648},{"artifact":0,"gen_end":1494,"gen_start":1237,"node":11,"role":"declaration","source":0,"src_end":2138,"src_start":1805},{"artifact":0,"gen_end":1632,"gen_start":1494,"node":12,"role":"declaration","source":0,"src_end":2336,"src_start":2140},{"artifact":0,"gen_end":1768,"gen_start":1632,"node":13,"role":"declaration","source":0,"src_end":2535,"src_start":2338},{"artifact":0,"gen_end":1788,"gen_start":1768,"node":0,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":14,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":1,"gen_end":379,"gen_start":134,"node":15,"role":"declaration","source":0,"src_end":307,"src_start":114},{"artifact":1,"gen_end":570,"gen_start":379,"node":16,"role":"declaration","source":0,"src_end":460,"src_start":309},{"artifact":1,"gen_end":731,"gen_start":570,"node":17,"role":"declaration","source":0,"src_end":585,"src_start":462},{"artifact":1,"gen_end":949,"gen_start":731,"node":18,"role":"declaration","source":0,"src_end":724,"src_start":587},{"artifact":1,"gen_end":1115,"gen_start":949,"node":19,"role":"declaration","source":0,"src_end":854,"src_start":726},{"artifact":1,"gen_end":1192,"gen_start":1115,"node":20,"role":"declaration","source":0,"src_end":1006,"src_start":856},{"artifact":1,"gen_end":1687,"gen_start":1192,"node":21,"role":"declaration","source":0,"src_end":1270,"src_start":1008},{"artifact":1,"gen_end":2077,"gen_start":1687,"node":22,"role":"declaration","source":0,"src_end":1487,"src_start":1272},{"artifact":1,"gen_end":2443,"gen_start":2077,"node":23,"role":"declaration","source":0,"src_end":1646,"src_start":1489},{"artifact":1,"gen_end":2791,"gen_start":2443,"node":24,"role":"declaration","source":0,"src_end":1803,"src_start":1648},{"artifact":1,"gen_end":3311,"gen_start":2791,"node":25,"role":"declaration","source":0,"src_end":2138,"src_start":1805},{"artifact":1,"gen_end":3747,"gen_start":3311,"node":26,"role":"declaration","source":0,"src_end":2336,"src_start":2140},{"artifact":1,"gen_end":4184,"gen_start":3747,"node":27,"role":"declaration","source":0,"src_end":2535,"src_start":2338},{"artifact":1,"gen_end":4199,"gen_start":4184,"node":14,"role":"declaration","source":0,"src_end":2571,"src_start":0}],"module":"Types","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-latex-module"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"}],"semantic_id":"f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd","source_id":"48db6ed4e506113ff1645455e567d1bd194ef0ffd92498a669c2326e3ac407bd","sources":[{"id":0,"kind":"file","path":"src/Types.lex.tex","sha256":"80d360f45ad31fccc43a06831cc6137982c579a23f3de646be93d3c3ce59193a"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Coverage/Types.lean"},{"id":1,"kind":"tex","path":"modules/Coverage/Types.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":0,"gen_end":325,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":307,"src_start":114},{"artifact":0,"gen_end":404,"gen_start":325,"node":2,"role":"declaration","source":0,"src_end":460,"src_start":309},{"artifact":0,"gen_end":454,"gen_start":404,"node":3,"role":"declaration","source":0,"src_end":585,"src_start":462},{"artifact":0,"gen_end":527,"gen_start":454,"node":4,"role":"declaration","source":0,"src_end":724,"src_start":587},{"artifact":0,"gen_end":582,"gen_start":527,"node":5,"role":"declaration","source":0,"src_end":854,"src_start":726},{"artifact":0,"gen_end":674,"gen_start":582,"node":6,"role":"declaration","source":0,"src_end":1006,"src_start":856},{"artifact":0,"gen_end":922,"gen_start":674,"node":7,"role":"declaration","source":0,"src_end":1270,"src_start":1008},{"artifact":0,"gen_end":1051,"gen_start":922,"node":8,"role":"declaration","source":0,"src_end":1487,"src_start":1272},{"artifact":0,"gen_end":1136,"gen_start":1051,"node":9,"role":"declaration","source":0,"src_end":1646,"src_start":1489},{"artifact":0,"gen_end":1237,"gen_start":1136,"node":10,"role":"declaration","source":0,"src_end":1803,"src_start":1648},{"artifact":0,"gen_end":1494,"gen_start":1237,"node":11,"role":"declaration","source":0,"src_end":2138,"src_start":1805},{"artifact":0,"gen_end":1632,"gen_start":1494,"node":12,"role":"declaration","source":0,"src_end":2336,"src_start":2140},{"artifact":0,"gen_end":1768,"gen_start":1632,"node":13,"role":"declaration","source":0,"src_end":2535,"src_start":2338},{"artifact":0,"gen_end":1788,"gen_start":1768,"node":0,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":14,"role":"declaration","source":0,"src_end":2571,"src_start":0},{"artifact":1,"gen_end":379,"gen_start":134,"node":15,"role":"declaration","source":0,"src_end":307,"src_start":114},{"artifact":1,"gen_end":570,"gen_start":379,"node":16,"role":"declaration","source":0,"src_end":460,"src_start":309},{"artifact":1,"gen_end":731,"gen_start":570,"node":17,"role":"declaration","source":0,"src_end":585,"src_start":462},{"artifact":1,"gen_end":949,"gen_start":731,"node":18,"role":"declaration","source":0,"src_end":724,"src_start":587},{"artifact":1,"gen_end":1115,"gen_start":949,"node":19,"role":"declaration","source":0,"src_end":854,"src_start":726},{"artifact":1,"gen_end":1192,"gen_start":1115,"node":20,"role":"declaration","source":0,"src_end":1006,"src_start":856},{"artifact":1,"gen_end":1687,"gen_start":1192,"node":21,"role":"declaration","source":0,"src_end":1270,"src_start":1008},{"artifact":1,"gen_end":2077,"gen_start":1687,"node":22,"role":"declaration","source":0,"src_end":1487,"src_start":1272},{"artifact":1,"gen_end":2443,"gen_start":2077,"node":23,"role":"declaration","source":0,"src_end":1646,"src_start":1489},{"artifact":1,"gen_end":2791,"gen_start":2443,"node":24,"role":"declaration","source":0,"src_end":1803,"src_start":1648},{"artifact":1,"gen_end":3311,"gen_start":2791,"node":25,"role":"declaration","source":0,"src_end":2138,"src_start":1805},{"artifact":1,"gen_end":3747,"gen_start":3311,"node":26,"role":"declaration","source":0,"src_end":2336,"src_start":2140},{"artifact":1,"gen_end":4184,"gen_start":3747,"node":27,"role":"declaration","source":0,"src_end":2535,"src_start":2338},{"artifact":1,"gen_end":4199,"gen_start":4184,"node":14,"role":"declaration","source":0,"src_end":2571,"src_start":0}],"module":"Types","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-latex-module"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"}],"semantic_id":"e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef","source_id":"1dfbb667271e4224522b0cb0324f88e4615f44a470a437f31cfa4ae7cfbb86ab","sources":[{"id":0,"kind":"file","path":"src/Types.lex.tex","sha256":"80d360f45ad31fccc43a06831cc6137982c579a23f3de646be93d3c3ce59193a"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.process.json similarity index 62% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.process.json index a4ab351d9..54d804b5e 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Boundary","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Boundary.Grove' does not depend on any axioms\n'Coverage.Boundary.Ledger' does not depend on any axioms\n'Coverage.Boundary.groveRoot' does not depend on any axioms\n'Coverage.Boundary.groveTags' does not depend on any axioms\n","stdout_sha256":"7ac4178ad6274022ed3970af26a3d40102c2d98c5667fc6435212b6084c7bf9b","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Boundary","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Boundary.Grove' does not depend on any axioms\n'Coverage.Boundary.Ledger' does not depend on any axioms\n'Coverage.Boundary.groveRoot' does not depend on any axioms\n'Coverage.Boundary.groveTags' does not depend on any axioms\n","stdout_sha256":"7ac4178ad6274022ed3970af26a3d40102c2d98c5667fc6435212b6084c7bf9b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.process.json similarity index 75% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.process.json index 18230e7e3..108698ef9 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Colls","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Colls.folds' does not depend on any axioms\n'Coverage.Colls.graphs' depends on axioms: [propext]\n'Coverage.Colls.iterations' does not depend on any axioms\n'Coverage.Colls.keyTypes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Colls.literals' does not depend on any axioms\n'Coverage.Colls.mapFolding' does not depend on any axioms\n'Coverage.Colls.mapOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Colls.setOps' does not depend on any axioms\n'Coverage.Colls.stringGraph' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"22e38c4026fd96a709d4105d50e6ac65f48242f5e698c1649f8970ca291870cf","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Colls","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Colls.folds' does not depend on any axioms\n'Coverage.Colls.graphs' depends on axioms: [propext]\n'Coverage.Colls.iterations' does not depend on any axioms\n'Coverage.Colls.keyTypes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Colls.literals' does not depend on any axioms\n'Coverage.Colls.mapFolding' does not depend on any axioms\n'Coverage.Colls.mapOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Colls.setOps' does not depend on any axioms\n'Coverage.Colls.stringGraph' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"22e38c4026fd96a709d4105d50e6ac65f48242f5e698c1649f8970ca291870cf","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.process.json similarity index 76% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.process.json index d4deb6f69..d272d2bf3 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Main.builders' does not depend on any axioms\n'Coverage.Main.double' does not depend on any axioms\n'Coverage.Main.higher' does not depend on any axioms\n'Coverage.Main.intOps' does not depend on any axioms\n'Coverage.Main.mapped' does not depend on any axioms\n'Coverage.Main.natOps' does not depend on any axioms\n'Coverage.Main.options' does not depend on any axioms\n'Coverage.Main.pairs' does not depend on any axioms\n'Coverage.Main.parity' does not depend on any axioms\n'Coverage.Main.records' does not depend on any axioms\n'Coverage.Main.shapes' does not depend on any axioms\n'Coverage.Main.treeTotal' does not depend on any axioms\n","stdout_sha256":"32540c1f973605f1e559888bfb26220c9d29afc1895ab69b12151845ab1ab3d4","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Main.builders' does not depend on any axioms\n'Coverage.Main.double' does not depend on any axioms\n'Coverage.Main.higher' does not depend on any axioms\n'Coverage.Main.intOps' does not depend on any axioms\n'Coverage.Main.mapped' does not depend on any axioms\n'Coverage.Main.natOps' does not depend on any axioms\n'Coverage.Main.options' does not depend on any axioms\n'Coverage.Main.pairs' does not depend on any axioms\n'Coverage.Main.parity' does not depend on any axioms\n'Coverage.Main.records' does not depend on any axioms\n'Coverage.Main.shapes' does not depend on any axioms\n'Coverage.Main.treeTotal' does not depend on any axioms\n","stdout_sha256":"32540c1f973605f1e559888bfb26220c9d29afc1895ab69b12151845ab1ab3d4","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.process.json similarity index 76% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.process.json index 4e1b72900..7d99715ba 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Prims","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Prims.bits' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.conversions' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.decimals' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Prims.fixedMiddle' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.fixedSmall' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.fixedWide' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.formats' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Prims.sequences' does not depend on any axioms\n'Coverage.Prims.text' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"5a91887912fd442dec7b31dc407e6d1b41e6daeae41243ead1c4fabccc1055ff","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Prims","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Prims.bits' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.conversions' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.decimals' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Prims.fixedMiddle' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.fixedSmall' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.fixedWide' depends on axioms: [propext, Quot.sound]\n'Coverage.Prims.formats' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Coverage.Prims.sequences' does not depend on any axioms\n'Coverage.Prims.text' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"5a91887912fd442dec7b31dc407e6d1b41e6daeae41243ead1c4fabccc1055ff","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.process.json similarity index 64% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.process.json index 2e3016317..9b1ce5fe5 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.RecRoots","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.RecRoots.rewrite' depends on axioms: [propext, Quot.sound]\n'Coverage.RecRoots.roseTotal' does not depend on any axioms\n'Coverage.RecRoots.syntaxTotal' does not depend on any axioms\n'Coverage.RecRoots.wellFounded' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"65dea254f3d66b71c29827ea8c418df77244a2d6c6272406aa0c3aecdba32862","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.RecRoots","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.RecRoots.rewrite' depends on axioms: [propext, Quot.sound]\n'Coverage.RecRoots.roseTotal' does not depend on any axioms\n'Coverage.RecRoots.syntaxTotal' does not depend on any axioms\n'Coverage.RecRoots.wellFounded' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"65dea254f3d66b71c29827ea8c418df77244a2d6c6272406aa0c3aecdba32862","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.process.json similarity index 88% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.process.json index 84002f6c9..e622c3aa3 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Recur","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Recur.countdown' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.exprSize' does not depend on any axioms\n'Coverage.Recur.foldExpr' does not depend on any axioms\n'Coverage.Recur.foldStatement' does not depend on any axioms\n'Coverage.Recur.foldStatements' does not depend on any axioms\n'Coverage.Recur.forestSize' does not depend on any axioms\n'Coverage.Recur.isEven' does not depend on any axioms\n'Coverage.Recur.isOdd' does not depend on any axioms\n'Coverage.Recur.ping' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.ping_seven' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.ping_to_pong' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.pong' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.pong_to_ping' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.prune' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.prune_plus' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate_literal' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate_plus' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reduce' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reduce_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.roseSize' does not depend on any axioms\n'Coverage.Recur.search' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.search_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.statementSize' does not depend on any axioms\n'Coverage.Recur.statementsSize' does not depend on any axioms\n'Coverage.Recur.weight' does not depend on any axioms\n","stdout_sha256":"d5be281da5138fa83388f122cca51fad6e839a61dd0f280ff086a543e047bc81","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Recur","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Recur.countdown' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.exprSize' does not depend on any axioms\n'Coverage.Recur.foldExpr' does not depend on any axioms\n'Coverage.Recur.foldStatement' does not depend on any axioms\n'Coverage.Recur.foldStatements' does not depend on any axioms\n'Coverage.Recur.forestSize' does not depend on any axioms\n'Coverage.Recur.isEven' does not depend on any axioms\n'Coverage.Recur.isOdd' does not depend on any axioms\n'Coverage.Recur.ping' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.ping_seven' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.ping_to_pong' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.pong' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.pong_to_ping' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.prune' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.prune_plus' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate_literal' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reassociate_plus' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reduce' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.reduce_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.roseSize' does not depend on any axioms\n'Coverage.Recur.search' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.search_decreases' depends on axioms: [propext, Quot.sound]\n'Coverage.Recur.statementSize' does not depend on any axioms\n'Coverage.Recur.statementsSize' does not depend on any axioms\n'Coverage.Recur.weight' does not depend on any axioms\n","stdout_sha256":"d5be281da5138fa83388f122cca51fad6e839a61dd0f280ff086a543e047bc81","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.process.json similarity index 61% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.process.json index c921e3421..20de5ffe9 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Syntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Syntax.Expr' does not depend on any axioms\n'Coverage.Syntax.Rose' does not depend on any axioms\n'Coverage.Syntax.Stmt' does not depend on any axioms\n'Coverage.Syntax.Term' does not depend on any axioms\n","stdout_sha256":"4b09296d7c1adfa883818c08a94022f67e3f873a80f2993277495aa5006c6a85","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Syntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Syntax.Expr' does not depend on any axioms\n'Coverage.Syntax.Rose' does not depend on any axioms\n'Coverage.Syntax.Stmt' does not depend on any axioms\n'Coverage.Syntax.Term' does not depend on any axioms\n","stdout_sha256":"4b09296d7c1adfa883818c08a94022f67e3f873a80f2993277495aa5006c6a85","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.process.json similarity index 77% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.process.json index 1010867ec..eec73cdb4 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.Coverage.Types","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Types.Box' does not depend on any axioms\n'Coverage.Types.Point' does not depend on any axioms\n'Coverage.Types.Shape' does not depend on any axioms\n'Coverage.Types.Tree' does not depend on any axioms\n'Coverage.Types.Weights' does not depend on any axioms\n'Coverage.Types.area' does not depend on any axioms\n'Coverage.Types.defaultWeights' does not depend on any axioms\n'Coverage.Types.isEven' does not depend on any axioms\n'Coverage.Types.isOdd' does not depend on any axioms\n'Coverage.Types.mapList' does not depend on any axioms\n'Coverage.Types.treeSum' does not depend on any axioms\n'Coverage.Types.twice' does not depend on any axioms\n'Coverage.Types.unbox' does not depend on any axioms\n","stdout_sha256":"7d45397351748355105332e8e732d26bd2b66ae398e097665e739867e574b3f7","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.Coverage.Types","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Coverage.Types.Box' does not depend on any axioms\n'Coverage.Types.Point' does not depend on any axioms\n'Coverage.Types.Shape' does not depend on any axioms\n'Coverage.Types.Tree' does not depend on any axioms\n'Coverage.Types.Weights' does not depend on any axioms\n'Coverage.Types.area' does not depend on any axioms\n'Coverage.Types.defaultWeights' does not depend on any axioms\n'Coverage.Types.isEven' does not depend on any axioms\n'Coverage.Types.isOdd' does not depend on any axioms\n'Coverage.Types.mapList' does not depend on any axioms\n'Coverage.Types.treeSum' does not depend on any axioms\n'Coverage.Types.twice' does not depend on any axioms\n'Coverage.Types.unbox' does not depend on any axioms\n","stdout_sha256":"7d45397351748355105332e8e732d26bd2b66ae398e097665e739867e574b3f7","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Collections.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.lean diff --git a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.process.json similarity index 97% rename from examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.process.json index 7443c5144..74f04fef6 100644 --- a/examples/collections/expected/verify/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A9962d043362f4a167c67517d483f0f24.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.lean diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.process.json similarity index 96% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.process.json index 8dca363df..6c4669ad7 100644 --- a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.lean b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.lean rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.process.json b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.process.json similarity index 98% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.process.json rename to examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.process.json index 852a4e75a..54abb4544 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.process.json +++ b/examples/production-coverage/expected/verify/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae05bf7cb47aac48ea11c4a7ac75c7962.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/extract/LexLeanExtract.Xf3572b43e36d5c62b7601d32507ebc3a.lean b/examples/production-coverage/expected/verify/extract/LexLeanExtract.Xe05bf7cb47aac48ea11c4a7ac75c7962.lean similarity index 100% rename from examples/production-coverage/expected/verify/extract/LexLeanExtract.Xf3572b43e36d5c62b7601d32507ebc3a.lean rename to examples/production-coverage/expected/verify/extract/LexLeanExtract.Xe05bf7cb47aac48ea11c4a7ac75c7962.lean diff --git a/examples/production-coverage/expected/verify/extract/process.json b/examples/production-coverage/expected/verify/extract/process.json index abc6734c3..bded471d5 100644 --- a/examples/production-coverage/expected/verify/extract/process.json +++ b/examples/production-coverage/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xf3572b43e36d5c62b7601d32507ebc3a.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xf3572b43e36d5c62b7601d32507ebc3a","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Coverage.Boundary.groveRoot\",\"Coverage.Colls.mapOps\",\"Coverage.Colls.mapFolding\",\"Coverage.Colls.setOps\",\"Coverage.Colls.folds\",\"Coverage.Colls.iterations\",\"Coverage.Colls.graphs\",\"Coverage.Colls.stringGraph\",\"Coverage.Colls.keyTypes\",\"Coverage.Colls.literals\",\"Coverage.Main.natOps\",\"Coverage.Main.intOps\",\"Coverage.Main.shapes\",\"Coverage.Main.treeTotal\",\"Coverage.Main.records\",\"Coverage.Main.options\",\"Coverage.Main.builders\",\"Coverage.Main.pairs\",\"Coverage.Main.higher\",\"Coverage.Main.mapped\",\"Coverage.Main.parity\",\"Coverage.Prims.fixedSmall\",\"Coverage.Prims.fixedMiddle\",\"Coverage.Prims.fixedWide\",\"Coverage.Prims.bits\",\"Coverage.Prims.conversions\",\"Coverage.Prims.sequences\",\"Coverage.Prims.decimals\",\"Coverage.Prims.formats\",\"Coverage.Prims.text\",\"Coverage.RecRoots.roseTotal\",\"Coverage.RecRoots.syntaxTotal\",\"Coverage.RecRoots.wellFounded\",\"Coverage.RecRoots.rewrite\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.compareCodes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Char\",\"List\",\"Ordering\",\"List.brecOn\",\"LexLeanCollections.compareCodes._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.eq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.lt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.gt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.compareCodes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.150\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.157\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Char\",\"index\":0,\"value\":\"_uniq.135\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Char\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.163\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.171\"}}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.195\"}}}]}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.207\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}]}}]}}}}}}}}}},\"uses\":[\"Char\",\"List\",\"Nat\",\"Ord\",\"Ordering\",\"PUnit\",\"UInt32\",\"instOrdNat\",\"LexLeanCollections.compareCodes\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"UInt32.toNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.containsElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}},\"uses\":[\"Bool\",\"List\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphNodes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.31\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphReachable\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.reachableFrom\",\"List.cons\",\"List.length\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphNodes\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.reachableFrom\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.reachableFrom\",\"List.cons\",\"List.lengthTR\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphSuccessors\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.nil\",\"Option.getD\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}},\"uses\":[\"List\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphTopological\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.topological\",\"List.length\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}]}}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphNodes\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.26\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.topological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.topological\",\"List.lengthTR\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5},{\"kind\":\"bvar\",\"index\":4}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"borrow\":false},{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.145\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"borrow\":false},{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.165\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyBool\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"instOrdBool\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}}}}},\"uses\":[\"Bool\",\"Ord\",\"Ordering\",\"instOrdBool\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOrdInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}}}}},\"uses\":[\"Int\",\"Ord\",\"Ordering\",\"instOrdInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"instOrdInt\",\"Int8.toInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.12\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Int\",\"Int8\",\"Ord\",\"Ordering\",\"instOrdInt\",\"Int8.toInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOrdNat\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"instOrdNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyProd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"Prod.fst\",\"Prod.snd\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.Key.mk\",\"LexLeanCollections.compareCodes.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},\"uses\":[\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanCollections.compareCodes\",\"String.toList\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.10\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.compareCodes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"uses\":[\"Char\",\"List\",\"Ordering\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.compareCodes\",\"String.toList\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyUInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instOrdNat\",\"Ord.compare\",\"UInt64.toNat\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.12\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"UInt64\",\"instOrdNat\",\"LexLeanCollections.Key\",\"UInt64.toNat\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.brecOn\",\"LexLeanCollections.iterate._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"bvar\",\"index\":1}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}},\"uses\":[\"Nat\",\"LexLeanCollections.iterate\",\"Nat.succ\",\"Nat.zero\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.lookupEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.lookupEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.126\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"borrow\":false},{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Option\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"Option.isSome\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Option.isSome\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}},\"uses\":[\"Bool\",\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"Option.isSome\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapEntries\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}},\"uses\":[\"List\",\"Prod\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.foldl\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}}},\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}}}},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}},\"uses\":[\"List\",\"Prod\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5},{\"kind\":\"bvar\",\"index\":4}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]}]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapKeys\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.map\",\"Prod.fst\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.23\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.mapTR\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"List\",\"Prod\",\"List.mapTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapLookup\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"uses\":[\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapRemove\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapSize\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"List.lengthTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapValues\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.map\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.23\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.mapTR\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"List\",\"Prod\",\"List.mapTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.Key\",\"Nat.brecOn\",\"LexLeanCollections.reachableFrom._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.119\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.238\",\"parameters\":[{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.198\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.195\",\"parameters\":[{\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.188\",\"parameters\":[{\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.183\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.191\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.188\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.194\",\"parameters\":[{\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.188\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.176\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.191\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.194\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.197\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.200\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.206\",\"parameters\":[{\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.206\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.220\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.217\",\"parameters\":[{\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.reachableFrom\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.219\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.220\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.230\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.235\",\"parameters\":[{\"id\":\"_uniq.233\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.221\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.234\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.235\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.236\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.238\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.106\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.245\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.247\"}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.insertElement\",\"LexLeanCollections.reachableFrom\",\"List.foldl\",\"List.nil\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.removeElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.removeElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.120\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.112\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.removeEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.removeEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.114\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.132\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.133\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"borrow\":false},{\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.153\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setDifference\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Bool.not\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filter\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.28\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Bool\",\"List\",\"Bool.not\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filterTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setElements\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}},\"uses\":[\"List\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setIntersection\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filter\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.27\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filterTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setRemove\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setSize\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"List\",\"Nat\",\"List.lengthTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setUnion\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.topological\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"Nat.brecOn\",\"LexLeanCollections.topological._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.isEmpty\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.118\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.120\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.reverse\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.207\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.167\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.isEmpty\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.160\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.reverse\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.167\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.180\",\"parameters\":[{\"id\":\"_uniq.175\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false},{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.topological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.179\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.180\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.199\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.196\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.all\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.200\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.202\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.203\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false},{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.181\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.214\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.208\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.removeElement\",\"LexLeanCollections.topological\",\"List.all\",\"List.cons\",\"List.filterTR\",\"List.isEmpty\",\"List.nil\",\"List.reverse\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Decimal\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Decimal.mk\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitAnd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitAnd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":4,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitNot\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitNot\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":7,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.26\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitOr\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":5,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitXor\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitXor\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedAdd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHAdd\",\"HAdd.hAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instAdd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"Option\",\"instHAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedAddInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instAddInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instLTInt64\",\"ite\",\"Bool.and\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HAdd.hAdd\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.159\",\"parameters\":[{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddInt64\",\"instDecidableEqBool\",\"instHAdd\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedConvert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}},\"uses\":[\"Int\",\"Option\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHMul\",\"HMul.hMul\",\"Int.instMul\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}}}}}}}},\"uses\":[\"HMul\",\"Int\",\"Mul\",\"Option\",\"instHMul\",\"Int.instMul\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiplyInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int64\",\"Nat\",\"Option\",\"UInt64\",\"Unit\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instLTInt64\",\"instOfNatNat\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"LexLeanRuntime.checkedMultiplyInt64.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"bne\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instOfNatNat\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instOfNat\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedNegate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int.instNegInt\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Neg.neg\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}}}}},\"uses\":[\"Int\",\"Neg\",\"Option\",\"Int.instNegInt\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedNegateInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"ite\",\"BEq.beq\",\"Bool.true\",\"Int64.instNeg\",\"Int64.instOfNat\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}]}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.instNeg\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedQuotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"instOfNat\",\"ite\",\"Int.instDecidableEq\",\"Int.tdiv\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"OfNat.ofNat\",\"Option.none\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"discriminant\":\"_uniq.40\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}]}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"instOfNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instDecidableEq\",\"Int.tdiv\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedQuotientInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Nat\",\"Option\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"instLTInt64\",\"instOfNatNat\",\"ite\",\"BEq.beq\",\"Bool.and\",\"Bool.true\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instNeg\",\"Int64.instOfNat\",\"LT.lt\",\"LexLeanRuntime.divideMagnitudeInt64\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.51\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.68\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.88\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"bne\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.115\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}}}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.91\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]}}}]}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"PUnit\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instNeg\",\"Int64.instOfNat\",\"LexLeanRuntime.divideMagnitudeInt64\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHSub\",\"HSub.hSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}}}}}}}},\"uses\":[\"HSub\",\"Int\",\"Option\",\"Sub\",\"instHSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtractInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instDecidableEqBool\",\"instHSub\",\"instLTInt64\",\"instSubInt64\",\"ite\",\"Bool.and\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HSub.hSub\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.159\",\"parameters\":[{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instHSub\",\"instSubInt64\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.compareBytes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"Ord.compare\",\"UInt8.instOrd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOrd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.instOrd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Ord\",\"Ordering\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"UInt8.instOrd\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"Nat.brecOn\",\"LexLeanRuntime.divideMagnitudeInt64._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.201\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.148\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.162\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.200\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.186\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.195\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.193\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.164\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.200\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.171\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.200\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.201\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.202\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}]}}}}}},\"uses\":[\"Add\",\"Decidable\",\"HAdd\",\"HSub\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instAddUInt64\",\"instHAdd\",\"instHSub\",\"instSubUInt64\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.divideMagnitudeInt64\",\"Nat.succ\",\"Nat.zero\",\"UInt64.decLe\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.formatDecimal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Decimal.format\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Decimal\",\"index\":1,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"String\",\"LexLeanRuntime.Decimal\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"String\",\"Unit\",\"instDecidableEqString\",\"instToStringInt\",\"ite\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"ToString.toString\",\"LexLeanRuntime.Decimal.mk\",\"LexLeanRuntime.instDecimalInt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toInt?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.71\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"PUnit\",\"String\",\"ToString\",\"instDecidableEqString\",\"instToStringInt\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Decimal\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"Unit.unit\",\"LexLeanRuntime.Decimal.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"String\",\"ToString\",\"Unit\",\"instDecidableEqString\",\"instToStringInt\",\"ite\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\",\"String.toInt?\",\"ToString.toString\",\"LexLeanRuntime.Decimal.mk\",\"LexLeanRuntime.instDecimalInt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toInt?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"PUnit\",\"String\",\"ToString\",\"instDecidableEqString\",\"instToStringInt\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"Unit.unit\",\"LexLeanRuntime.Decimal.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt16\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int16\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int16.complement\",\"Int16.land\",\"Int16.lor\",\"Int16.ofInt\",\"Int16.ofNat\",\"Int16.shiftLeft\",\"Int16.shiftRight\",\"Int16.toInt\",\"Int16.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32768\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32767\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int16\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int16.complement\",\"Int16.land\",\"Int16.lor\",\"Int16.ofInt\",\"Int16.ofNat\",\"Int16.shiftLeft\",\"Int16.shiftRight\",\"Int16.toInt\",\"Int16.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int32\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int32.complement\",\"Int32.land\",\"Int32.lor\",\"Int32.ofInt\",\"Int32.ofNat\",\"Int32.shiftLeft\",\"Int32.shiftRight\",\"Int32.toInt\",\"Int32.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2147483648\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2147483647\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int32\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int32.complement\",\"Int32.land\",\"Int32.lor\",\"Int32.ofInt\",\"Int32.ofNat\",\"Int32.shiftLeft\",\"Int32.shiftRight\",\"Int32.toInt\",\"Int32.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int64\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int64.complement\",\"Int64.land\",\"Int64.lor\",\"Int64.ofInt\",\"Int64.ofNat\",\"Int64.shiftLeft\",\"Int64.shiftRight\",\"Int64.toInt\",\"Int64.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775807\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int64.complement\",\"Int64.land\",\"Int64.lor\",\"Int64.ofInt\",\"Int64.ofNat\",\"Int64.shiftLeft\",\"Int64.shiftRight\",\"Int64.toInt\",\"Int64.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int8.complement\",\"Int8.land\",\"Int8.lor\",\"Int8.ofInt\",\"Int8.ofNat\",\"Int8.shiftLeft\",\"Int8.shiftRight\",\"Int8.toInt\",\"Int8.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"127\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int8\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int8.complement\",\"Int8.land\",\"Int8.lor\",\"Int8.ofInt\",\"Int8.ofNat\",\"Int8.shiftLeft\",\"Int8.shiftRight\",\"Int8.toInt\",\"Int8.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt16\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt16\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt16.complement\",\"UInt16.land\",\"UInt16.lor\",\"UInt16.ofInt\",\"UInt16.ofNat\",\"UInt16.shiftLeft\",\"UInt16.shiftRight\",\"UInt16.toNat\",\"UInt16.xor\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"65535\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt16\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt16.complement\",\"UInt16.land\",\"UInt16.lor\",\"UInt16.ofInt\",\"UInt16.ofNat\",\"UInt16.shiftLeft\",\"UInt16.shiftRight\",\"UInt16.toNat\",\"UInt16.xor\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4294967295\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"UInt64\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt64.complement\",\"UInt64.land\",\"UInt64.lor\",\"UInt64.ofInt\",\"UInt64.ofNat\",\"UInt64.shiftLeft\",\"UInt64.shiftRight\",\"UInt64.toNat\",\"UInt64.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"18446744073709551615\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"UInt64\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt64.complement\",\"UInt64.land\",\"UInt64.lor\",\"UInt64.ofInt\",\"UInt64.ofNat\",\"UInt64.shiftLeft\",\"UInt64.shiftRight\",\"UInt64.toNat\",\"UInt64.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanRuntime.listIndex\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},{\"kind\":\"bvar\",\"index\":0}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.listIndex\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.listIndex\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"String.length\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"Nat\",\"String\",\"LexLeanRuntime.Lengthable\",\"String.length\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instBEqOfDecidableEq\",\"instOfNat\",\"BEq.beq\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tmod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instOfNat\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"BEq.beq\",\"Nat.div\",\"Nat.mod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.div\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.mod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"Nat.div\",\"Nat.mod\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"HAdd.hAdd\",\"LE.le\",\"List.drop\",\"List.length\",\"List.take\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.drop\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.takeTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"Add\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"List.drop\",\"List.lengthTR\",\"List.takeTR\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instToMathIntInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.4\",\"parameters\":[{\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"Int\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.join\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"String\",\"String.intercalate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.intercalate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"List\",\"String\",\"String.intercalate\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"List.brecOn\",\"LexLeanRuntime.listIndex._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.listIndex\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}]}}]}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"LexLeanRuntime.listIndex\",\"List.cons\",\"List.nil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.magnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int64\",\"UInt64\",\"instHSub\",\"instLTInt64\",\"instSubUInt64\",\"ite\",\"HSub.hSub\",\"Int64.decLt\",\"Int64.instOfNat\",\"Int64.toUInt64\",\"LT.lt\",\"OfNat.ofNat\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Int64\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}}}}]}}}}}}}},\"uses\":[\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instHSub\",\"instSubUInt64\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"UInt64\",\"Nat.brecOn\",\"LexLeanRuntime.multiplyMagnitudeInt64._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.138\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.295\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.294\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.184\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.293\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.202\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.212\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.213\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.216\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.218\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.231\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.232\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.234\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.235\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.251\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.250\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.251\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.261\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.256\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.257\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.259\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.260\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.262\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.261\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.282\",\"parameters\":[{\"id\":\"_uniq.273\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.273\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.274\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.219\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.277\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.278\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.279\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.280\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.280\"}}}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.285\",\"parameters\":[{\"id\":\"_uniq.283\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.262\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.283\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.282\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.288\",\"parameters\":[{\"id\":\"_uniq.286\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.286\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.282\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.287\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.268\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.285\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.288\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.271\"}]}}}]}}}}}}}}}}}]}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.290\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.291\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.291\"}}}]}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.194\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4611686018427387903\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.196\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.198\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4611686018427387904\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.200\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]}}}}}]}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775807\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.294\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.180\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.182\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.294\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]}}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.295\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.302\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.302\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.303\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.303\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.304\"}}}]}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"HSub\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Sub\",\"UInt64\",\"instAddUInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instSubUInt64\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"UInt64.decLe\",\"UInt64.decLt\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.negate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Neg\",\"Neg.neg\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}},\"uses\":[\"Neg\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.parseDecimal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Decimal.parse\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Decimal\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Option\",\"String\",\"LexLeanRuntime.Decimal\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.remainder\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":1,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.shiftLeft\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.shiftLeft\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":8,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.shiftRight\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.shiftRight\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":9,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt64\",\"instDecidableEqBool\",\"instHSub\",\"instSubUInt64\",\"ite\",\"Bool.true\",\"HSub.hSub\",\"OfNat.ofNat\",\"UInt64.instOfNat\",\"UInt64.toInt64\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"discriminant\":\"_uniq.25\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instDecidableEqBool\",\"instHSub\",\"instSubUInt64\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"UInt64.instOfNat\",\"UInt64.toInt64\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.splitExact\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"String\",\"UInt32\",\"instDecidableEqBool\",\"instLTNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"LT.lt\",\"List.length\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"String.isEmpty\",\"String.splitOn\",\"UInt32.toNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.splitOn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.isEmpty\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.86\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]}}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"String\",\"UInt32\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"List.lengthTR\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"String.isEmpty\",\"String.splitOn\",\"UInt32.toNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Decode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"String.fromUTF8?\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.fromUTF8?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"Option\",\"String\",\"String.fromUTF8?\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Encode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.toUTF8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.toUTF8\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"String.toUTF8\"]},\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove\",\"kind\":\"inductive\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Boundary.Grove.node\",\"parameters\":0,\"fields\":5,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}}}}}},{\"name\":\"Coverage.Boundary.Grove.leaf\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}},{\"name\":\"Coverage.Boundary.Grove.settled\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}}]}},{\"name\":\"Coverage.Boundary.Ledger\",\"kind\":\"inductive\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Boundary.Ledger.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Boundary.groveRoot\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Prod.mk\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Ledger\",\"Coverage.Boundary.groveTags\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.groveTags\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Prod.mk\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Ledger\",\"Coverage.Boundary.groveTags\"]},\"inductive\":null},{\"name\":\"Coverage.Boundary.groveTags\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"instOfNatNat\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.setSize\",\"OfNat.ofNat\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.groveTags.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Boundary.Grove\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.node\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.leaf\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.settled\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}]}}}}}}}},\"uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"String\",\"instOfNatNat\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.setSize\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.settled\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.folds\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNat\",\"instOfNatNat\",\"HAdd.hAdd\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setFold\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.25\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNat\",\"instOfNatNat\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setFold\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.graphs\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.graphReachable\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphReachable\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphTopological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphReachable\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.iterations\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterate\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.27\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterate\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.keyTypes\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int\",\"Int8\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"UInt64\",\"LexLeanCollections.instKeyBool\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.instKeyInt8\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.instKeyUInt64\",\"LexLeanCollections.mapLookup\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}}}}}}}}}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Int\",\"Int8\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"UInt64\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyBool\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.instKeyInt8\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.instKeyUInt64\",\"LexLeanCollections.mapLookup\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.literals\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"String\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"a\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"b\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"String\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.mapFolding\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.mapFold\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.mapFold\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.mapOps\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.mapContains\",\"LexLeanCollections.mapEntries\",\"LexLeanCollections.mapInsert\",\"LexLeanCollections.mapKeys\",\"LexLeanCollections.mapLookup\",\"LexLeanCollections.mapRemove\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.mapValues\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapRemove\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapKeys\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapValues\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapEntries\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.mapContains\",\"LexLeanCollections.mapEntries\",\"LexLeanCollections.mapInsert\",\"LexLeanCollections.mapKeys\",\"LexLeanCollections.mapLookup\",\"LexLeanCollections.mapRemove\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.mapValues\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.setOps\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setDifference\",\"LexLeanCollections.setElements\",\"LexLeanCollections.setInsert\",\"LexLeanCollections.setIntersection\",\"LexLeanCollections.setRemove\",\"LexLeanCollections.setSize\",\"LexLeanCollections.setUnion\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setRemove\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setUnion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setIntersection\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setDifference\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setElements\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setDifference\",\"LexLeanCollections.setElements\",\"LexLeanCollections.setInsert\",\"LexLeanCollections.setIntersection\",\"LexLeanCollections.setRemove\",\"LexLeanCollections.setSize\",\"LexLeanCollections.setUnion\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.stringGraph\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"String\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyString\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphTopological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"List\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyString\"]},\"inductive\":null},{\"name\":\"Coverage.Main.builders\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Nat.blt\",\"Nat.succ\",\"Nat.zero\",\"OfNat.ofNat\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.succ\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.zero\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Nat.blt\",\"Nat.succ\",\"Nat.zero\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.double\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\"]},\"inductive\":null},{\"name\":\"Coverage.Main.higher\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Coverage.Main.double\",\"Coverage.Types.twice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.twice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Main.double\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.twice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Mul\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.subtract\",\"Coverage.Main.double\",\"Coverage.Types.twice\"]},\"inductive\":null},{\"name\":\"Coverage.Main.intOps\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\"]},\"inductive\":null},{\"name\":\"Coverage.Main.mapped\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Coverage.Types.isEven\",\"Coverage.Types.mapList\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isEven\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.mapList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Coverage.Types.isEven\",\"Coverage.Types.mapList\"]},\"inductive\":null},{\"name\":\"Coverage.Main.natOps\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.and\",\"Bool.not\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.102\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.133\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.121\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.127\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}}}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.136\",\"parameters\":[{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.133\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.133\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Mul\",\"Nat\",\"OfNat\",\"PUnit\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.options\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Main.options.match_1\",\"Coverage.Main.options.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.131\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.96\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.103\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}]}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.130\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]}}]}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.134\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.137\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"Except\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.pairs\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Prod\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"Bool\",\"Nat\",\"Prod\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Main.parity\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.isOdd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isOdd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Nat\",\"Coverage.Types.isOdd\"]},\"inductive\":null},{\"name\":\"Coverage.Main.records\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.mk\",\"Coverage.Types.Point\",\"Coverage.Types.defaultWeights\",\"Coverage.Types.unbox\",\"Coverage.Types.Box.mk\",\"Coverage.Types.Point.mk\",\"Coverage.Types.Point.x\",\"Coverage.Types.Point.y\",\"Coverage.Types.Weights.scale\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Point\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.defaultWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Weights\",\"index\":1,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Point\",\"index\":1,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.unbox\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Prod.mk\",\"Coverage.Types.Box\",\"Coverage.Types.Point\",\"Coverage.Types.Weights\",\"Coverage.Types.defaultWeights\",\"Coverage.Types.unbox\",\"Coverage.Types.Box.mk\",\"Coverage.Types.Point.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Main.shapes\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Coverage.Types.area\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.rect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.circle\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.empty\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Coverage.Types.Shape\",\"Coverage.Types.area\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"]},\"inductive\":null},{\"name\":\"Coverage.Main.treeTotal\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.leaf\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.node\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.node\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Coverage.Types.Tree\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.bits\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Option\",\"Prod\",\"UInt16\",\"UInt32\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt16\",\"LexLeanRuntime.bitAnd\",\"LexLeanRuntime.bitNot\",\"LexLeanRuntime.bitOr\",\"LexLeanRuntime.bitXor\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.shiftLeft\",\"LexLeanRuntime.shiftRight\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt32.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitAnd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitOr\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitXor\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitNot\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt16\",\"UInt32\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt16\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.bitAnd\",\"LexLeanRuntime.bitNot\",\"LexLeanRuntime.bitOr\",\"LexLeanRuntime.bitXor\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.shiftLeft\",\"LexLeanRuntime.shiftRight\",\"Prod.mk\",\"UInt32.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.conversions\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int64\",\"Int8\",\"Option\",\"UInt16\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.instFixedInt64\",\"LexLeanRuntime.instFixedInt8\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.instToMathIntInt\",\"Prod.mk\",\"LexLeanRuntime.Fixed.toToMathInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instToMathIntInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Int\",\"Int64\",\"Int8\",\"Option\",\"Prod\",\"UInt16\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.instFixedInt64\",\"LexLeanRuntime.instFixedInt8\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.instToMathIntInt\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.decimals\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"String\",\"UInt32\",\"instToStringUInt32\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedUInt32\",\"LexLeanRuntime.parseDecimal\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.parseDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.parseDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}}}},\"uses\":[\"Int\",\"Option\",\"Prod\",\"String\",\"ToString\",\"UInt32\",\"instToStringUInt32\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedUInt32\",\"LexLeanRuntime.parseDecimal\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedMiddle\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int16\",\"Int32\",\"Option\",\"Prod\",\"instBEqOfDecidableEq\",\"instDecidableEqInt32\",\"Int32.instNeg\",\"Int32.instOfNat\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedInt16\",\"LexLeanRuntime.instFixedInt32\",\"Neg.neg\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanRuntime.Fixed.toToMathInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int16\",\"Int32\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"Prod\",\"instBEqOfDecidableEq\",\"instDecidableEqInt32\",\"Int32.instNeg\",\"Int32.instOfNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedInt16\",\"LexLeanRuntime.instFixedInt32\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedSmall\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int8\",\"Option\",\"Prod\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.checkedNegate\",\"LexLeanRuntime.checkedQuotient\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedQuotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedNegate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Int8\",\"Option\",\"Prod\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.checkedNegate\",\"LexLeanRuntime.checkedQuotient\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedWide\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int64\",\"Option\",\"Prod\",\"UInt64\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedAddInt64\",\"LexLeanRuntime.checkedMultiplyInt64\",\"LexLeanRuntime.checkedNegateInt64\",\"LexLeanRuntime.checkedQuotientInt64\",\"LexLeanRuntime.checkedSubtractInt64\",\"LexLeanRuntime.instFixedUInt64\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAddInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtractInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiplyInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedQuotientInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedNegateInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}}}}},\"uses\":[\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt64\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedAddInt64\",\"LexLeanRuntime.checkedMultiplyInt64\",\"LexLeanRuntime.checkedNegateInt64\",\"LexLeanRuntime.checkedQuotientInt64\",\"LexLeanRuntime.checkedSubtractInt64\",\"LexLeanRuntime.instFixedUInt64\",\"Prod.mk\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.formats\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"String\",\"instToStringInt8\",\"LexLeanRuntime.formatDecimal\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.formatDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.formatDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}},\"uses\":[\"Int\",\"Int8\",\"Prod\",\"String\",\"ToString\",\"instToStringInt8\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.formatDecimal\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.sequences\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"HAdd.hAdd\",\"LexLeanRuntime.append\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instAppendableByteArray\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"LexLeanRuntime.instIndexableList\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.instSliceableList\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instAppendableByteArray\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"LexLeanRuntime.instIndexableList\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.instSliceableList\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Prod.mk\",\"UInt8.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.text\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"Ordering\",\"Prod\",\"String\",\"UInt32\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"instDecidableEqString\",\"Bool.and\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableString\",\"LexLeanRuntime.join\",\"LexLeanRuntime.length\",\"LexLeanRuntime.splitExact\",\"LexLeanRuntime.utf8Decode\",\"LexLeanRuntime.utf8Encode\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt32.instOfNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Decode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"255\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.splitExact\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"x\\\"y\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.join\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"discriminant\":\"_uniq.92\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Ordering\",\"PUnit\",\"Prod\",\"String\",\"UInt32\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"instDecidableEqString\",\"Bool.false\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableString\",\"LexLeanRuntime.join\",\"LexLeanRuntime.length\",\"LexLeanRuntime.splitExact\",\"LexLeanRuntime.utf8Decode\",\"LexLeanRuntime.utf8Encode\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Prod.mk\",\"UInt32.instOfNat\",\"UInt8.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.rewrite\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Prod.mk\",\"Coverage.Recur.prune\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"Prod\",\"Prod.mk\",\"Coverage.Recur.prune\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.roseTotal\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose.node\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose.node\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.roseSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.syntaxTotal\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Recur.exprSize\",\"Coverage.Syntax.Expr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Coverage.Recur.exprSize\",\"Coverage.Syntax.Expr\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.wellFounded\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Coverage.Recur.countdown\",\"Coverage.Recur.reduce\",\"Coverage.Recur.search\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reduce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.search\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\",\"Coverage.Recur.countdown\",\"Coverage.Recur.reduce\",\"Coverage.Recur.search\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.countdown\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PSigma.mk\",\"Coverage.Recur.countdown._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Coverage.Recur.countdown\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.countdown_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._proof_1_32\",\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Expr.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementsSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Expr\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.literal\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.plus\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.block\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}]}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.exprSize\",\"Coverage.Recur.statementsSize\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize._f\",\"Coverage.Recur.roseSize._f\",\"Coverage.Syntax.Rose.brecOn_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.roseSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.forestSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.36\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Recur.forestSize\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.prune\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"LT.lt\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"WellFounded.Nat.fix\",\"Coverage.Recur.prune._proof_1\",\"Coverage.Recur.prune._proof_2\",\"Coverage.Recur.reassociate.match_1\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.149\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}},\"uses\":[\"Nat\",\"Coverage.Recur.prune\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.prune_plus\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congr\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.prune_plus._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"LT.lt\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"WellFounded.Nat.fix\",\"Coverage.Recur.reassociate._proof_1\",\"Coverage.Recur.reassociate._proof_2\",\"Coverage.Recur.reassociate.match_1\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.149\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.112\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}},\"uses\":[\"Nat\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate_literal\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_literal._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate_plus\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congr\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_plus._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Recur.reduce._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reduce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.118\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"Coverage.Recur.reduce\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.reduce_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.beq_eq\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._proof_1_32\",\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize._f\",\"Coverage.Recur.roseSize._f\",\"Coverage.Syntax.Rose.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.forestSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Rose\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Rose.node\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.forestSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.search\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Recur.search._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.search\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.106\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.132\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.132\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Coverage.Recur.search\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.search_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"HAdd.hAdd\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.search_decreases._proof_1_32\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Stmt.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Stmt\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Stmt.assign\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Stmt.sequence\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"String\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.exprSize\",\"Coverage.Recur.statementSize\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.sequence\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Expr.brecOn_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementsSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Recur.statementSize\",\"Coverage.Recur.statementsSize\",\"Coverage.Syntax.Stmt\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.weight\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Recur.weight._f\",\"Coverage.Syntax.Term.brecOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Expr.literal\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}},{\"name\":\"Coverage.Syntax.Expr.plus\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}}},{\"name\":\"Coverage.Syntax.Expr.block\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Syntax.Rose\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Rose.node\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"Coverage.Syntax.Stmt\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Stmt.assign\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}}}},{\"name\":\"Coverage.Syntax.Stmt.sequence\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Syntax.Term\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Term.literal\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},{\"name\":\"Coverage.Syntax.Term.plus\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.Box\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Box.mk\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"Coverage.Types.Point\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Point.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.Shape\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Shape.circle\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}},{\"name\":\"Coverage.Types.Shape.rect\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}}},{\"name\":\"Coverage.Types.Shape.empty\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}]}},{\"name\":\"Coverage.Types.Tree\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Types.Tree.leaf\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]}},{\"name\":\"Coverage.Types.Tree.node\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]}}}}}]}},{\"name\":\"Coverage.Types.Weights\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Weights.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.area\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Coverage.Types.Shape\",\"Coverage.Types.area.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Types.Shape\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.circle\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.rect\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.empty\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}]}}}}}}}},\"uses\":[\"Mul\",\"Nat\",\"OfNat\",\"PUnit\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"Unit.unit\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"]},\"inductive\":null},{\"name\":\"Coverage.Types.defaultWeights\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Coverage.Types.Weights.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Coverage.Types.Weights\",\"Coverage.Types.Weights.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Types.isEven\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Nat.below\",\"Nat.brecOn\",\"PProd.mk\",\"Coverage.Types.isEven._f\",\"Coverage.Types.isOdd._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isOdd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"PUnit\",\"Bool.true\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\",\"Coverage.Types.isOdd\"]},\"inductive\":null},{\"name\":\"Coverage.Types.isOdd\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Nat.below\",\"Nat.brecOn\",\"PProd.mk\",\"Coverage.Types.isEven._f\",\"Coverage.Types.isOdd._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isEven\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"PUnit\",\"Bool.false\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\",\"Coverage.Types.isEven\"]},\"inductive\":null},{\"name\":\"Coverage.Types.mapList\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.brecOn\",\"Coverage.Types.mapList._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":1}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.90\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.mapList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}]}}}}}},\"uses\":[\"List\",\"List.cons\",\"List.nil\",\"Coverage.Types.mapList\"]},\"inductive\":null},{\"name\":\"Coverage.Types.treeSum\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.brecOn\",\"Coverage.Types.treeSum._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Types.Tree\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Tree.leaf\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Tree.node\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Unit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"]},\"inductive\":null},{\"name\":\"Coverage.Types.twice\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\"]},\"inductive\":null},{\"name\":\"Coverage.Types.unbox\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Box\",\"Coverage.Types.Box.content\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"bvar\",\"index\":1}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Box\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}},\"uses\":[\"Coverage.Types.Box\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Char\",\"List\",\"Nat\",\"Ordering\",\"Unit\",\"instOrdNat\",\"Char.val\",\"List.below\",\"List.cons\",\"List.nil\",\"Ord.compare\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"UInt32.toNat\",\"LexLeanCollections.compareCodes.match_1\",\"LexLeanCollections.compareCodes.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.compareCodes._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_4\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Char\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Ordering.casesOn\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Prod.casesOn\",\"Prod.mk\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"LexLeanCollections.iterate.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lookupEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Option\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"LexLeanCollections.reachableFrom.match_1\",\"LexLeanCollections.reachableFrom.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"List.cons\",\"List.ctorIdx\",\"List.nil\",\"List.rec\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.ctorIdx\",\"List.nil\",\"Nat.hasNotBit\",\"Unit.unit\",\"LexLeanCollections.reachableFrom._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom.match_4\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.removeElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.removeEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.topological._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.not\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.removeElement\",\"List.all\",\"List.cons\",\"List.filter\",\"List.isEmpty\",\"List.reverse\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.reachableFrom.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.format\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.parse\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitAnd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitNot\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitOr\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitXor\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.shiftLeft\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.shiftRight\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiplyInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt64\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instAddUInt64\",\"instHAdd\",\"instHSub\",\"instLEUInt64\",\"instOfNatNat\",\"instSubUInt64\",\"ite\",\"HAdd.hAdd\",\"HSub.hSub\",\"LE.le\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"UInt64.decLe\",\"UInt64.instOfNat\",\"LexLeanRuntime.divideMagnitudeInt64.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalInt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.listIndex.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"UInt64\",\"instAddUInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLEUInt64\",\"instLTUInt64\",\"instOfNatNat\",\"instSubUInt64\",\"ite\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HAdd.hAdd\",\"HSub.hSub\",\"LE.le\",\"LT.lt\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.decLe\",\"UInt64.decLt\",\"UInt64.instOfNat\",\"LexLeanRuntime.multiplyMagnitudeInt64.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"UInt64\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"PUnit.unit\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.rec\",\"Coverage.Boundary.Grove.settled\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.leaf\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.settled\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.groveTags.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.casesOn\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.settled\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Main.options.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Main.options.match_3\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.countdown._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Eq.refl\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize.match_1\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.casesOn\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize.match_1\",\"Coverage.Syntax.Rose.below_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Syntax.Rose\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.prune._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_literal\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.prune._proof_2\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.prune_plus\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_literal\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate._proof_2\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_plus\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Eq.refl\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.casesOn\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.reduce._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.roseSize.match_1\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.casesOn\",\"Coverage.Syntax.Rose.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.search._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.search._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"String\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.statementSize.match_1\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.casesOn\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.statementsSize.match_1\",\"Coverage.Syntax.Expr.below_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Syntax.Stmt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.weight._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Term\",\"Coverage.Recur.weight.match_1\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.weight.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.casesOn\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.below_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.block\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Expr.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Expr.brecOn_1.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PUnit\",\"String\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.literal\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.plus\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.rec_1\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.below_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.brecOn_1.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PUnit\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.rec_1\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.assign\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PUnit\",\"String\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.rec\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.sequence\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.literal\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.plus\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Box.content\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Box\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Box.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.x\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Point\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.y\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Point\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rec\",\"Coverage.Types.Shape.rect\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.circle\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.empty\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.rect\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.below\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.leaf\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Weights.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Weights.scale\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Weights\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.area.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.casesOn\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isEven._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Unit\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"Nat.zero\",\"Coverage.Types.isEven.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isEven.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Nat.casesOn\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isOdd._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Unit\",\"Bool.false\",\"Nat.below\",\"Nat.succ\",\"Nat.zero\",\"Coverage.Types.isEven.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.mapList._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"List.below\",\"List.cons\",\"List.nil\",\"Coverage.Types.mapList.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.mapList.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.treeSum._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.treeSum.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.treeSum.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.casesOn\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.prune_plus._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.natCast_nonneg\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_literal._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_plus._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.natCast_nonneg\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"GT.gt\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_nonneg\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Nat.lt_or_gt_of_ne\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.search_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_3\",\"Lean.Omega.LinearCombo.coordinate_eval_4\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"Coverage.Recur.countdown_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Coverage.Recur.reduce_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.search._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Coverage.Recur.search_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn_1.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec_1\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn_1.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.rec\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Char\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int16\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int32\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int64\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int8\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Neg\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"String\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ToString\",\"kind\":\"inductive\",\"module\":\"Init.Data.ToString.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt16\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt64\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"bne\",\"kind\":\"definition\",\"module\":\"Init.Core\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddUInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqInt32\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqOrdering\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqString\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt16\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdBool\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubUInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringInt\",\"kind\":\"definition\",\"module\":\"Init.Data.ToString.Extra\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringInt8\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringUInt32\",\"kind\":\"definition\",\"module\":\"Init.Data.ToString.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.decide\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instAdd\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instMul\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instNegInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"Int.tdiv\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tmod\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.instNeg\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.instNeg\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.all\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.drop\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.filterTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.isEmpty\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.mapTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.reverse\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.takeTR\",\"kind\":\"axiom\",\"module\":\"Init.Data.List.Impl\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.div\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.mod\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.isSome\",\"kind\":\"definition\",\"module\":\"Init.Data.Option.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.eq\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.gt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"String.fromUTF8?\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.intercalate\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.isEmpty\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.length\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Length\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.splitOn\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Legacy\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toInt?\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Search\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toUTF8\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.decLe\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.toInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.UInt\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"61bc88661e5d1048dfc867a9b847049b2c9eeceed3cb0f4da5fc8437c0fab574","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xe05bf7cb47aac48ea11c4a7ac75c7962.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xe05bf7cb47aac48ea11c4a7ac75c7962","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Coverage.Boundary.groveRoot\",\"Coverage.Colls.mapOps\",\"Coverage.Colls.mapFolding\",\"Coverage.Colls.setOps\",\"Coverage.Colls.folds\",\"Coverage.Colls.iterations\",\"Coverage.Colls.graphs\",\"Coverage.Colls.stringGraph\",\"Coverage.Colls.keyTypes\",\"Coverage.Colls.literals\",\"Coverage.Main.natOps\",\"Coverage.Main.intOps\",\"Coverage.Main.shapes\",\"Coverage.Main.treeTotal\",\"Coverage.Main.records\",\"Coverage.Main.options\",\"Coverage.Main.builders\",\"Coverage.Main.pairs\",\"Coverage.Main.higher\",\"Coverage.Main.mapped\",\"Coverage.Main.parity\",\"Coverage.Prims.fixedSmall\",\"Coverage.Prims.fixedMiddle\",\"Coverage.Prims.fixedWide\",\"Coverage.Prims.bits\",\"Coverage.Prims.conversions\",\"Coverage.Prims.sequences\",\"Coverage.Prims.decimals\",\"Coverage.Prims.formats\",\"Coverage.Prims.text\",\"Coverage.RecRoots.roseTotal\",\"Coverage.RecRoots.syntaxTotal\",\"Coverage.RecRoots.wellFounded\",\"Coverage.RecRoots.rewrite\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.compareCodes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Char\",\"List\",\"Ordering\",\"List.brecOn\",\"LexLeanCollections.compareCodes._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.eq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.lt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Ordering.gt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.compareCodes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.150\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.157\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Char\",\"index\":0,\"value\":\"_uniq.135\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Char\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.163\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.171\"}}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.195\"}}}]}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.207\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}]}}]}}}}}}}}}},\"uses\":[\"Char\",\"List\",\"Nat\",\"Ord\",\"Ordering\",\"PUnit\",\"UInt32\",\"instOrdNat\",\"LexLeanCollections.compareCodes\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"UInt32.toNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.containsElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}},\"uses\":[\"Bool\",\"List\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphNodes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.31\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphReachable\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.reachableFrom\",\"List.cons\",\"List.length\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphNodes\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.reachableFrom\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.reachableFrom\",\"List.cons\",\"List.lengthTR\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphSuccessors\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.nil\",\"Option.getD\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}},\"uses\":[\"List\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.graphTopological\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.topological\",\"List.length\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}]}}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphNodes\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.26\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.topological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphNodes\",\"LexLeanCollections.topological\",\"List.lengthTR\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5},{\"kind\":\"bvar\",\"index\":4}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"borrow\":false},{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.145\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"borrow\":false},{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"discriminant\":\"_uniq.165\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},\"borrow\":false},{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyBool\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"instOrdBool\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}}}}},\"uses\":[\"Bool\",\"Ord\",\"Ordering\",\"instOrdBool\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOrdInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}}}}},\"uses\":[\"Int\",\"Ord\",\"Ordering\",\"instOrdInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"instOrdInt\",\"Int8.toInt\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.12\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Int\",\"Int8\",\"Ord\",\"Ordering\",\"instOrdInt\",\"Int8.toInt\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOrdNat\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"instOrdNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyProd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"Prod.fst\",\"Prod.snd\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.Key.mk\",\"LexLeanCollections.compareCodes.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},\"uses\":[\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanCollections.compareCodes\",\"String.toList\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.10\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Char\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.compareCodes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"uses\":[\"Char\",\"List\",\"Ordering\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.compareCodes\",\"String.toList\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyUInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instOrdNat\",\"Ord.compare\",\"UInt64.toNat\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.12\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.8\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"UInt64\",\"instOrdNat\",\"LexLeanCollections.Key\",\"UInt64.toNat\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Nat.brecOn\",\"LexLeanCollections.iterate._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"bvar\",\"index\":1}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}},\"uses\":[\"Nat\",\"LexLeanCollections.iterate\",\"Nat.succ\",\"Nat.zero\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.lookupEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.lookupEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.126\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"borrow\":false},{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},\"borrow\":false},{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Option\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"Option.isSome\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Option.isSome\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}},\"uses\":[\"Bool\",\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\",\"Option.isSome\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapEntries\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}},\"uses\":[\"List\",\"Prod\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.foldl\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}}},\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}}}},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.86\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}},\"uses\":[\"List\",\"Prod\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5},{\"kind\":\"bvar\",\"index\":4}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]}]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapKeys\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.map\",\"Prod.fst\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.23\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.mapTR\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"List\",\"Prod\",\"List.mapTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapLookup\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.lookupEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"uses\":[\"List\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.lookupEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapRemove\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapSize\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"List.lengthTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.mapValues\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"List.map\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.23\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.mapTR\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"List\",\"Prod\",\"List.mapTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.Key\",\"Nat.brecOn\",\"LexLeanCollections.reachableFrom._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.119\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.238\",\"parameters\":[{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.198\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.195\",\"parameters\":[{\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.188\",\"parameters\":[{\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.183\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.191\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.188\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.194\",\"parameters\":[{\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.188\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.176\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.191\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.194\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.197\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.198\"},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.200\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.206\",\"parameters\":[{\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.206\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.220\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.217\",\"parameters\":[{\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"borrow\":false},{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.reachableFrom\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.219\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.220\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.230\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.235\",\"parameters\":[{\"id\":\"_uniq.233\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.221\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.234\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.235\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.236\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.238\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"discriminant\":\"_uniq.106\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.245\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.247\"}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.insertElement\",\"LexLeanCollections.reachableFrom\",\"List.foldl\",\"List.nil\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.removeElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.removeElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.120\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.112\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.120\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.removeEntry\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.removeEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4},{\"kind\":\"bvar\",\"index\":3}]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.114\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.132\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.133\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"borrow\":false},{\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Prod\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"discriminant\":\"_uniq.153\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Prod.mk\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},\"borrow\":false},{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}]}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeEntry\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setDifference\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Bool.not\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filter\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.28\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Bool\",\"List\",\"Bool.not\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filterTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setElements\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}},\"uses\":[\"List\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setIntersection\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filter\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.27\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.filterTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setRemove\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.removeElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setSize\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"List\",\"Nat\",\"List.lengthTR\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setUnion\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.topological\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"Nat.brecOn\",\"LexLeanCollections.topological._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":5}]}]}}}}}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.isEmpty\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.118\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.120\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.reverse\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.207\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false},{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.167\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.isEmpty\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.160\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.reverse\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.167\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.180\",\"parameters\":[{\"id\":\"_uniq.175\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false},{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.removeElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.topological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.179\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.180\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.199\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.196\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.all\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.filterTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.199\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.200\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.202\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.203\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},\"borrow\":false},{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.181\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.214\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.208\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.removeElement\",\"LexLeanCollections.topological\",\"List.all\",\"List.cons\",\"List.filterTR\",\"List.isEmpty\",\"List.nil\",\"List.reverse\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Decimal\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Decimal.mk\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitAnd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitAnd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":4,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitNot\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitNot\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":7,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.26\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitOr\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":5,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.bitXor\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.bitXor\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"uses\":[\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedAdd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHAdd\",\"HAdd.hAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instAdd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"Option\",\"instHAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedAddInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instAddInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instLTInt64\",\"ite\",\"Bool.and\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HAdd.hAdd\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.159\",\"parameters\":[{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddInt64\",\"instDecidableEqBool\",\"instHAdd\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedConvert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}},\"uses\":[\"Int\",\"Option\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHMul\",\"HMul.hMul\",\"Int.instMul\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}}}}}}}},\"uses\":[\"HMul\",\"Int\",\"Mul\",\"Option\",\"instHMul\",\"Int.instMul\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiplyInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int64\",\"Nat\",\"Option\",\"UInt64\",\"Unit\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instLTInt64\",\"instOfNatNat\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"LexLeanRuntime.checkedMultiplyInt64.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"bne\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instOfNatNat\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instOfNat\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedNegate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int.instNegInt\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Neg.neg\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}}}}},\"uses\":[\"Int\",\"Neg\",\"Option\",\"Int.instNegInt\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedNegateInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"ite\",\"BEq.beq\",\"Bool.true\",\"Int64.instNeg\",\"Int64.instOfNat\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.24\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}]}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.instNeg\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedQuotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"instOfNat\",\"ite\",\"Int.instDecidableEq\",\"Int.tdiv\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"OfNat.ofNat\",\"Option.none\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"discriminant\":\"_uniq.40\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}]}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"instOfNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instDecidableEq\",\"Int.tdiv\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedQuotientInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Nat\",\"Option\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"instLTInt64\",\"instOfNatNat\",\"ite\",\"BEq.beq\",\"Bool.and\",\"Bool.true\",\"Decidable.decide\",\"Int64.decLt\",\"Int64.instNeg\",\"Int64.instOfNat\",\"LT.lt\",\"LexLeanRuntime.divideMagnitudeInt64\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.51\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.68\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.88\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"bne\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.111\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.magnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.115\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}}}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.126\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.123\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.91\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]}}}]}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"PUnit\",\"UInt64\",\"bne\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqInt64\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instNeg\",\"Int64.instOfNat\",\"LexLeanRuntime.divideMagnitudeInt64\",\"LexLeanRuntime.magnitudeInt64\",\"LexLeanRuntime.signedMagnitudeInt64\",\"Option.none\",\"Option.some\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHSub\",\"HSub.hSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}}}}}}}},\"uses\":[\"HSub\",\"Int\",\"Option\",\"Sub\",\"instHSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtractInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int64\",\"Option\",\"instDecidableEqBool\",\"instHSub\",\"instLTInt64\",\"instSubInt64\",\"ite\",\"Bool.and\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HSub.hSub\",\"Int64.decLt\",\"Int64.instOfNat\",\"LT.lt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.131\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.159\",\"parameters\":[{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.152\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"},{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.146\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instHSub\",\"instSubInt64\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.compareBytes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"Ord.compare\",\"UInt8.instOrd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOrd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.instOrd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Ord\",\"Ordering\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"UInt8.instOrd\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"Nat.brecOn\",\"LexLeanRuntime.divideMagnitudeInt64._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.201\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.148\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.162\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.200\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.186\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.194\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.195\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"},{\"kind\":\"fvar\",\"id\":\"_uniq.196\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.divideMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.193\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.198\"}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.164\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.200\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.171\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.200\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.201\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.202\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}]}}}}}},\"uses\":[\"Add\",\"Decidable\",\"HAdd\",\"HSub\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instAddUInt64\",\"instHAdd\",\"instHSub\",\"instSubUInt64\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.divideMagnitudeInt64\",\"Nat.succ\",\"Nat.zero\",\"UInt64.decLe\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.formatDecimal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Decimal.format\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Decimal\",\"index\":1,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"String\",\"LexLeanRuntime.Decimal\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"String\",\"Unit\",\"instDecidableEqString\",\"instToStringInt\",\"ite\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"ToString.toString\",\"LexLeanRuntime.Decimal.mk\",\"LexLeanRuntime.instDecimalInt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toInt?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.71\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"PUnit\",\"String\",\"ToString\",\"instDecidableEqString\",\"instToStringInt\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Decimal\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"Unit.unit\",\"LexLeanRuntime.Decimal.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Int\",\"Option\",\"String\",\"ToString\",\"Unit\",\"instDecidableEqString\",\"instToStringInt\",\"ite\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\",\"String.toInt?\",\"ToString.toString\",\"LexLeanRuntime.Decimal.mk\",\"LexLeanRuntime.instDecimalInt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.toInt?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"ToString\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"PUnit\",\"String\",\"ToString\",\"instDecidableEqString\",\"instToStringInt\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"Option.none\",\"Option.some\",\"String.toInt?\",\"Unit.unit\",\"LexLeanRuntime.Decimal.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt16\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int16\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int16.complement\",\"Int16.land\",\"Int16.lor\",\"Int16.ofInt\",\"Int16.ofNat\",\"Int16.shiftLeft\",\"Int16.shiftRight\",\"Int16.toInt\",\"Int16.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32768\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32767\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int16.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int16.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int16\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int16.complement\",\"Int16.land\",\"Int16.lor\",\"Int16.ofInt\",\"Int16.ofNat\",\"Int16.shiftLeft\",\"Int16.shiftRight\",\"Int16.toInt\",\"Int16.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int32\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int32.complement\",\"Int32.land\",\"Int32.lor\",\"Int32.ofInt\",\"Int32.ofNat\",\"Int32.shiftLeft\",\"Int32.shiftRight\",\"Int32.toInt\",\"Int32.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2147483648\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2147483647\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int32\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int32.complement\",\"Int32.land\",\"Int32.lor\",\"Int32.ofInt\",\"Int32.ofNat\",\"Int32.shiftLeft\",\"Int32.shiftRight\",\"Int32.toInt\",\"Int32.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int64\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int64.complement\",\"Int64.land\",\"Int64.lor\",\"Int64.ofInt\",\"Int64.ofNat\",\"Int64.shiftLeft\",\"Int64.shiftRight\",\"Int64.toInt\",\"Int64.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775807\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int64.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int64\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int64.complement\",\"Int64.land\",\"Int64.lor\",\"Int64.ofInt\",\"Int64.ofNat\",\"Int64.shiftLeft\",\"Int64.shiftRight\",\"Int64.toInt\",\"Int64.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.instNegInt\",\"Int8.complement\",\"Int8.land\",\"Int8.lor\",\"Int8.ofInt\",\"Int8.ofNat\",\"Int8.shiftLeft\",\"Int8.shiftRight\",\"Int8.toInt\",\"Int8.xor\",\"LT.lt\",\"Nat.decLt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.toInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"127\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Int8.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"discriminant\":\"_uniq.68\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int8.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Int8\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.instNegInt\",\"Int8.complement\",\"Int8.land\",\"Int8.lor\",\"Int8.ofInt\",\"Int8.ofNat\",\"Int8.shiftLeft\",\"Int8.shiftRight\",\"Int8.toInt\",\"Int8.xor\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt16\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt16\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt16.complement\",\"UInt16.land\",\"UInt16.lor\",\"UInt16.ofInt\",\"UInt16.ofNat\",\"UInt16.shiftLeft\",\"UInt16.shiftRight\",\"UInt16.toNat\",\"UInt16.xor\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"65535\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"16\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt16.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt16\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt16.complement\",\"UInt16.land\",\"UInt16.lor\",\"UInt16.ofInt\",\"UInt16.ofNat\",\"UInt16.shiftLeft\",\"UInt16.shiftRight\",\"UInt16.toNat\",\"UInt16.xor\",\"UInt32.toNat\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4294967295\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"UInt64\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt64.complement\",\"UInt64.land\",\"UInt64.lor\",\"UInt64.ofInt\",\"UInt64.ofNat\",\"UInt64.shiftLeft\",\"UInt64.shiftRight\",\"UInt64.toNat\",\"UInt64.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"18446744073709551615\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"UInt64\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt64.complement\",\"UInt64.land\",\"UInt64.lor\",\"UInt64.ofInt\",\"UInt64.ofNat\",\"UInt64.shiftLeft\",\"UInt64.shiftRight\",\"UInt64.toNat\",\"UInt64.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanRuntime.listIndex\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},{\"kind\":\"bvar\",\"index\":0}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.listIndex\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.listIndex\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableString\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"String.length\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"Nat\",\"String\",\"LexLeanRuntime.Lengthable\",\"String.length\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instBEqOfDecidableEq\",\"instOfNat\",\"BEq.beq\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tdiv\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.tmod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"Int.instDecidableEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instOfNat\",\"Int.instDecidableEq\",\"Int.tdiv\",\"Int.tmod\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"BEq.beq\",\"Nat.div\",\"Nat.mod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.div\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.mod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"Nat.div\",\"Nat.mod\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"HAdd.hAdd\",\"LE.le\",\"List.drop\",\"List.length\",\"List.take\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"discriminant\":\"_uniq.31\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.drop\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.takeTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"Add\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"List.drop\",\"List.lengthTR\",\"List.takeTR\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instToMathIntInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.4\",\"parameters\":[{\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"Int\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.join\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"String\",\"String.intercalate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.intercalate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"List\",\"String\",\"String.intercalate\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"List.brecOn\",\"LexLeanRuntime.listIndex._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.listIndex\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"borrow\":false}],\"code\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}]}}]}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"LexLeanRuntime.listIndex\",\"List.cons\",\"List.nil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.magnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int64\",\"UInt64\",\"instHSub\",\"instLTInt64\",\"instSubUInt64\",\"ite\",\"HSub.hSub\",\"Int64.decLt\",\"Int64.instOfNat\",\"Int64.toUInt64\",\"LT.lt\",\"OfNat.ofNat\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Int64\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.33\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}}}}}]}}}}}}}},\"uses\":[\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instHSub\",\"instSubUInt64\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int64.decLt\",\"Int64.instOfNat\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"UInt64\",\"Nat.brecOn\",\"LexLeanRuntime.multiplyMagnitudeInt64._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.138\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.295\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.294\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.184\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.293\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.202\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.203\"},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.212\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.213\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.216\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"},{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.218\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.231\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.232\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.234\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.235\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.251\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.250\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.251\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.261\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.256\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.257\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.259\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.260\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.262\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.261\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.282\",\"parameters\":[{\"id\":\"_uniq.273\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.273\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.274\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.219\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"},{\"kind\":\"fvar\",\"id\":\"_uniq.277\"},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.278\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.279\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.280\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.280\"}}}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.285\",\"parameters\":[{\"id\":\"_uniq.283\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.262\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.283\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.282\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.288\",\"parameters\":[{\"id\":\"_uniq.286\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.286\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.282\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.287\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.268\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.285\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.288\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.271\"}]}}}]}}}}}}}}}}}]}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.290\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.291\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.291\"}}}]}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.194\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4611686018427387903\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.196\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.198\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4611686018427387904\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.199\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.200\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]}}}}}]}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775807\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.294\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.180\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9223372036854775808\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.182\"},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.294\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]}}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.295\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.302\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.302\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.303\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.303\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.304\"}}}]}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"HSub\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Sub\",\"UInt64\",\"instAddUInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instSubUInt64\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.multiplyMagnitudeInt64\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"UInt64.decLe\",\"UInt64.decLt\",\"UInt64.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.negate\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Neg\",\"Neg.neg\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}},\"uses\":[\"Neg\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.parseDecimal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Decimal.parse\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Decimal\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Option\",\"String\",\"LexLeanRuntime.Decimal\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.remainder\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":1,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.shiftLeft\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.shiftLeft\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":8,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.shiftRight\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.Fixed.shiftRight\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":9,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.signedMagnitudeInt64\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt64\",\"instDecidableEqBool\",\"instHSub\",\"instSubUInt64\",\"ite\",\"Bool.true\",\"HSub.hSub\",\"OfNat.ofNat\",\"UInt64.instOfNat\",\"UInt64.toInt64\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.toInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"discriminant\":\"_uniq.25\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"HSub\",\"Int64\",\"Nat\",\"OfNat\",\"Sub\",\"UInt64\",\"instDecidableEqBool\",\"instHSub\",\"instSubUInt64\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"UInt64.instOfNat\",\"UInt64.toInt64\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.splitExact\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"String\",\"UInt32\",\"instDecidableEqBool\",\"instLTNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"LT.lt\",\"List.length\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"String.isEmpty\",\"String.splitOn\",\"UInt32.toNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.splitOn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Decidable.decide\",\"levels\":[],\"arguments\":[{\"kind\":\"erased\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.isEmpty\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.86\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]}}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"String\",\"UInt32\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.decide\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"List.lengthTR\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"String.isEmpty\",\"String.splitOn\",\"UInt32.toNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Decode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"String.fromUTF8?\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"String.fromUTF8?\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"Option\",\"String\",\"String.fromUTF8?\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Encode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.toUTF8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.toUTF8\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"String.toUTF8\"]},\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove\",\"kind\":\"inductive\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Boundary.Grove.node\",\"parameters\":0,\"fields\":5,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}}}}}},{\"name\":\"Coverage.Boundary.Grove.leaf\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}},{\"name\":\"Coverage.Boundary.Grove.settled\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}}}]}},{\"name\":\"Coverage.Boundary.Ledger\",\"kind\":\"inductive\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Boundary.Ledger.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Boundary.groveRoot\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Prod.mk\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Ledger\",\"Coverage.Boundary.groveTags\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.groveTags\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Ledger\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Prod.mk\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Ledger\",\"Coverage.Boundary.groveTags\"]},\"inductive\":null},{\"name\":\"Coverage.Boundary.groveTags\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"instOfNatNat\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.setSize\",\"OfNat.ofNat\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.groveTags.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Boundary.Grove\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.node\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.leaf\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Boundary.Grove.settled\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Boundary.Grove\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}]}}}}}}}},\"uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"String\",\"instOfNatNat\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.setSize\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.settled\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.folds\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNat\",\"instOfNatNat\",\"HAdd.hAdd\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setFold\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.25\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNat\",\"instOfNatNat\",\"Int.instSub\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setFold\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.graphs\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.graphReachable\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphSuccessors\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphReachable\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphTopological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphReachable\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.iterations\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterate\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.27\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterate\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.keyTypes\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int\",\"Int8\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"UInt64\",\"LexLeanCollections.instKeyBool\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.instKeyInt8\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.instKeyUInt64\",\"LexLeanCollections.mapLookup\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}}}}}}}}}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Int\",\"Int8\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"UInt64\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyBool\",\"LexLeanCollections.instKeyInt\",\"LexLeanCollections.instKeyInt8\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.instKeyUInt64\",\"LexLeanCollections.mapLookup\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.literals\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"String\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"a\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"b\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"String\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.mapFolding\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.mapFold\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.mapFold\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.mapOps\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.mapContains\",\"LexLeanCollections.mapEntries\",\"LexLeanCollections.mapInsert\",\"LexLeanCollections.mapKeys\",\"LexLeanCollections.mapLookup\",\"LexLeanCollections.mapRemove\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.mapValues\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapRemove\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapLookup\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapKeys\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapValues\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.mapEntries\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyString\",\"LexLeanCollections.mapContains\",\"LexLeanCollections.mapEntries\",\"LexLeanCollections.mapInsert\",\"LexLeanCollections.mapKeys\",\"LexLeanCollections.mapLookup\",\"LexLeanCollections.mapRemove\",\"LexLeanCollections.mapSize\",\"LexLeanCollections.mapValues\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.setOps\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setDifference\",\"LexLeanCollections.setElements\",\"LexLeanCollections.setInsert\",\"LexLeanCollections.setIntersection\",\"LexLeanCollections.setRemove\",\"LexLeanCollections.setSize\",\"LexLeanCollections.setUnion\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setRemove\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setUnion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setIntersection\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setDifference\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setElements\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setDifference\",\"LexLeanCollections.setElements\",\"LexLeanCollections.setInsert\",\"LexLeanCollections.setIntersection\",\"LexLeanCollections.setRemove\",\"LexLeanCollections.setSize\",\"LexLeanCollections.setUnion\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Colls.stringGraph\",\"kind\":\"definition\",\"module\":\"Coverage.Colls\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"String\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyString\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.graphTopological\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"List\",\"Option\",\"Prod\",\"String\",\"LexLeanCollections.Key\",\"LexLeanCollections.graphTopological\",\"LexLeanCollections.instKeyString\"]},\"inductive\":null},{\"name\":\"Coverage.Main.builders\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Nat.blt\",\"Nat.succ\",\"Nat.zero\",\"OfNat.ofNat\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.succ\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.zero\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Nat.blt\",\"Nat.succ\",\"Nat.zero\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.double\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\"]},\"inductive\":null},{\"name\":\"Coverage.Main.higher\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Coverage.Main.double\",\"Coverage.Types.twice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.twice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Main.double\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.twice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Mul\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.subtract\",\"Coverage.Main.double\",\"Coverage.Types.twice\"]},\"inductive\":null},{\"name\":\"Coverage.Main.intOps\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Neg.neg\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instMul\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instNegInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.negate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Int\",\"Mul\",\"Nat\",\"Neg\",\"OfNat\",\"Sub\",\"instOfNat\",\"Int.instMul\",\"Int.instNegInt\",\"Int.instSub\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientInt\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.negate\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\"]},\"inductive\":null},{\"name\":\"Coverage.Main.mapped\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"Coverage.Types.isEven\",\"Coverage.Types.mapList\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isEven\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.mapList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"Coverage.Types.isEven\",\"Coverage.Types.mapList\"]},\"inductive\":null},{\"name\":\"Coverage.Main.natOps\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.and\",\"Bool.not\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.100\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.102\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.133\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.121\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.127\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}}}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.136\",\"parameters\":[{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.133\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.139\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.133\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Mul\",\"Nat\",\"OfNat\",\"PUnit\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instMulNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.multiply\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.options\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Main.options.match_1\",\"Coverage.Main.options.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.131\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.96\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.103\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}]}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.130\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.130\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]}}]}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.134\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.137\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.134\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.137\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"Except\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.Main.pairs\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Prod\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"Bool\",\"Nat\",\"Prod\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Main.parity\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.isOdd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isOdd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Nat\",\"Coverage.Types.isOdd\"]},\"inductive\":null},{\"name\":\"Coverage.Main.records\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.mk\",\"Coverage.Types.Point\",\"Coverage.Types.defaultWeights\",\"Coverage.Types.unbox\",\"Coverage.Types.Box.mk\",\"Coverage.Types.Point.mk\",\"Coverage.Types.Point.x\",\"Coverage.Types.Point.y\",\"Coverage.Types.Weights.scale\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Point\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.defaultWeights\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Weights\",\"index\":1,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Point\",\"index\":1,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.unbox\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Prod.mk\",\"Coverage.Types.Box\",\"Coverage.Types.Point\",\"Coverage.Types.Weights\",\"Coverage.Types.defaultWeights\",\"Coverage.Types.unbox\",\"Coverage.Types.Box.mk\",\"Coverage.Types.Point.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Main.shapes\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Coverage.Types.area\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.rect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.circle\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape.empty\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Coverage.Types.Shape\",\"Coverage.Types.area\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"]},\"inductive\":null},{\"name\":\"Coverage.Main.treeTotal\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.leaf\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"5\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.node\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree.node\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Coverage.Types.Tree\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.bits\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Option\",\"Prod\",\"UInt16\",\"UInt32\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt16\",\"LexLeanRuntime.bitAnd\",\"LexLeanRuntime.bitNot\",\"LexLeanRuntime.bitOr\",\"LexLeanRuntime.bitXor\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.shiftLeft\",\"LexLeanRuntime.shiftRight\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt32.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitAnd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitOr\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitXor\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.bitNot\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt16\",\"UInt32\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt16\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.bitAnd\",\"LexLeanRuntime.bitNot\",\"LexLeanRuntime.bitOr\",\"LexLeanRuntime.bitXor\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.shiftLeft\",\"LexLeanRuntime.shiftRight\",\"Prod.mk\",\"UInt32.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.conversions\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int64\",\"Int8\",\"Option\",\"UInt16\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.instFixedInt64\",\"LexLeanRuntime.instFixedInt8\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.instToMathIntInt\",\"Prod.mk\",\"LexLeanRuntime.Fixed.toToMathInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instToMathIntInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Int\",\"Int64\",\"Int8\",\"Option\",\"Prod\",\"UInt16\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.instFixedInt64\",\"LexLeanRuntime.instFixedInt8\",\"LexLeanRuntime.instFixedUInt16\",\"LexLeanRuntime.instToMathIntInt\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.decimals\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"String\",\"UInt32\",\"instToStringUInt32\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedUInt32\",\"LexLeanRuntime.parseDecimal\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.parseDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.parseDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}}}}}}},\"uses\":[\"Int\",\"Option\",\"Prod\",\"String\",\"ToString\",\"UInt32\",\"instToStringUInt32\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedUInt32\",\"LexLeanRuntime.parseDecimal\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedMiddle\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Int16\",\"Int32\",\"Option\",\"Prod\",\"instBEqOfDecidableEq\",\"instDecidableEqInt32\",\"Int32.instNeg\",\"Int32.instOfNat\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedInt16\",\"LexLeanRuntime.instFixedInt32\",\"Neg.neg\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanRuntime.Fixed.toToMathInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt16\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Neg\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instNeg\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Neg\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"7\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedConvert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int16\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int32\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Int16\",\"Int32\",\"Nat\",\"Neg\",\"OfNat\",\"Option\",\"Prod\",\"instBEqOfDecidableEq\",\"instDecidableEqInt32\",\"Int32.instNeg\",\"Int32.instOfNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedConvert\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instFixedInt16\",\"LexLeanRuntime.instFixedInt32\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedSmall\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int8\",\"Option\",\"Prod\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.checkedNegate\",\"LexLeanRuntime.checkedQuotient\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedQuotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedNegate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Int8\",\"Option\",\"Prod\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedMultiply\",\"LexLeanRuntime.checkedNegate\",\"LexLeanRuntime.checkedQuotient\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.fixedWide\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int64\",\"Option\",\"Prod\",\"UInt64\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedAddInt64\",\"LexLeanRuntime.checkedMultiplyInt64\",\"LexLeanRuntime.checkedNegateInt64\",\"LexLeanRuntime.checkedQuotientInt64\",\"LexLeanRuntime.checkedSubtractInt64\",\"LexLeanRuntime.instFixedUInt64\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt64.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAddInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtractInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedMultiplyInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedQuotientInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedNegateInt64\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt64\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt64.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int64\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt64\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}}}}}}}}}}}}}},\"uses\":[\"Int64\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt64\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.checkedAddInt64\",\"LexLeanRuntime.checkedMultiplyInt64\",\"LexLeanRuntime.checkedNegateInt64\",\"LexLeanRuntime.checkedQuotientInt64\",\"LexLeanRuntime.checkedSubtractInt64\",\"LexLeanRuntime.instFixedUInt64\",\"Prod.mk\",\"UInt64.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.formats\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Int8\",\"String\",\"instToStringInt8\",\"LexLeanRuntime.formatDecimal\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.formatDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"ToString\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instToStringInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Decimal\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.formatDecimal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}},\"uses\":[\"Int\",\"Int8\",\"Prod\",\"String\",\"ToString\",\"instToStringInt8\",\"LexLeanRuntime.Decimal\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.formatDecimal\",\"LexLeanRuntime.instDecimalInt\",\"LexLeanRuntime.instDecimalOfFixedOfToString\",\"LexLeanRuntime.instFixedInt8\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.sequences\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"HAdd.hAdd\",\"LexLeanRuntime.append\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instAppendableByteArray\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"LexLeanRuntime.instIndexableList\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.instSliceableList\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instAppendableByteArray\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"LexLeanRuntime.instIndexableList\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.instSliceableList\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Prod.mk\",\"UInt8.instOfNat\"]},\"inductive\":null},{\"name\":\"Coverage.Prims.text\",\"kind\":\"definition\",\"module\":\"Coverage.Prims\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"Ordering\",\"Prod\",\"String\",\"UInt32\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"instDecidableEqString\",\"Bool.and\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableString\",\"LexLeanRuntime.join\",\"LexLeanRuntime.length\",\"LexLeanRuntime.splitExact\",\"LexLeanRuntime.utf8Decode\",\"LexLeanRuntime.utf8Encode\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"Prod.mk\",\"UInt32.instOfNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Decode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"255\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.splitExact\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"x\\\"y\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.join\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqString\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]}]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}]}]}]}]}]},\"discriminant\":\"_uniq.92\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Ordering\",\"PUnit\",\"Prod\",\"String\",\"UInt32\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"instDecidableEqString\",\"Bool.false\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableString\",\"LexLeanRuntime.join\",\"LexLeanRuntime.length\",\"LexLeanRuntime.splitExact\",\"LexLeanRuntime.utf8Decode\",\"LexLeanRuntime.utf8Encode\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Prod.mk\",\"UInt32.instOfNat\",\"UInt8.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.rewrite\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Prod.mk\",\"Coverage.Recur.prune\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"Prod\",\"Prod.mk\",\"Coverage.Recur.prune\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.roseTotal\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose.node\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose.node\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.roseSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.syntaxTotal\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Recur.exprSize\",\"Coverage.Syntax.Expr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Coverage.Recur.exprSize\",\"Coverage.Syntax.Expr\"]},\"inductive\":null},{\"name\":\"Coverage.RecRoots.wellFounded\",\"kind\":\"definition\",\"module\":\"Coverage.RecRoots\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Coverage.Recur.countdown\",\"Coverage.Recur.reduce\",\"Coverage.Recur.search\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reduce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.search\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\",\"Coverage.Recur.countdown\",\"Coverage.Recur.reduce\",\"Coverage.Recur.search\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.countdown\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PSigma.mk\",\"Coverage.Recur.countdown._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Coverage.Recur.countdown\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.countdown_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._proof_1_32\",\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Expr.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementsSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Expr\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.literal\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.plus\",\"parameters\":[{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Expr.block\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}]}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.exprSize\",\"Coverage.Recur.statementsSize\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize._f\",\"Coverage.Recur.roseSize._f\",\"Coverage.Syntax.Rose.brecOn_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.roseSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.forestSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.36\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Recur.forestSize\",\"Coverage.Recur.roseSize\",\"Coverage.Syntax.Rose\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.prune\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"LT.lt\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"WellFounded.Nat.fix\",\"Coverage.Recur.prune._proof_1\",\"Coverage.Recur.prune._proof_2\",\"Coverage.Recur.reassociate.match_1\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.149\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.prune\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}},\"uses\":[\"Nat\",\"Coverage.Recur.prune\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.prune_plus\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congr\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.prune_plus._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"LT.lt\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"WellFounded.Nat.fix\",\"Coverage.Recur.reassociate._proof_1\",\"Coverage.Recur.reassociate._proof_2\",\"Coverage.Recur.reassociate.match_1\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.149\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.literal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term.plus\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reassociate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.112\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.171\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Term\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"discriminant\":\"_uniq.155\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.literal\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Term.plus\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.169\"}}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}}}}}},\"uses\":[\"Nat\",\"Coverage.Recur.reassociate\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate_literal\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_literal._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate_plus\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Not\",\"congr\",\"congrArg\",\"congrFun'\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"Decidable.byContradiction\",\"Eq.mpr\",\"Eq.ndrec\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"LT.lt\",\"Nat.add_assoc\",\"Nat.decLt\",\"OfNat.ofNat\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\",\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_plus._proof_1_35\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Recur.reduce._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.reduce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.118\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"Coverage.Recur.reduce\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.reduce_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.beq_eq\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._proof_1_32\",\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize._f\",\"Coverage.Recur.roseSize._f\",\"Coverage.Syntax.Rose.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.forestSize\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Rose\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Rose.node\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.forestSize\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.search\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Recur.search._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.search\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.106\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.132\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.132\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Coverage.Recur.search\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.search_decreases\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"HAdd.hAdd\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Coverage.Recur.0.Coverage.Recur.search_decreases._proof_1_32\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Stmt.brecOn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.exprSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Syntax.Stmt\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Stmt.assign\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Syntax.Stmt.sequence\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"String\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Coverage.Recur.exprSize\",\"Coverage.Recur.statementSize\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.sequence\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize._f\",\"Coverage.Recur.statementSize._f\",\"Coverage.Recur.statementsSize._f\",\"Coverage.Syntax.Expr.brecOn_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Recur.statementsSize\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Recur.statementSize\",\"Coverage.Recur.statementsSize\",\"Coverage.Syntax.Stmt\"]},\"inductive\":null},{\"name\":\"Coverage.Recur.weight\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Recur.weight._f\",\"Coverage.Syntax.Term.brecOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Expr.literal\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}},{\"name\":\"Coverage.Syntax.Expr.plus\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}}},{\"name\":\"Coverage.Syntax.Expr.block\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Syntax.Rose\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Rose.node\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Rose\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"Coverage.Syntax.Stmt\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Stmt.assign\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Expr\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}}}},{\"name\":\"Coverage.Syntax.Stmt.sequence\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Stmt\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Syntax.Term\",\"kind\":\"inductive\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Syntax.Term.literal\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}},{\"name\":\"Coverage.Syntax.Term.plus\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Syntax.Term\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.Box\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Box.mk\",\"parameters\":1,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}}]}},{\"name\":\"Coverage.Types.Point\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Point.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Point\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.Shape\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Shape.circle\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}},{\"name\":\"Coverage.Types.Shape.rect\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}}},{\"name\":\"Coverage.Types.Shape.empty\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]}}]}},{\"name\":\"Coverage.Types.Tree\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":true,\"constructors\":[{\"name\":\"Coverage.Types.Tree.leaf\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]}},{\"name\":\"Coverage.Types.Tree.node\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]}}}}}]}},{\"name\":\"Coverage.Types.Weights\",\"kind\":\"inductive\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Coverage.Types.Weights.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]}}}}]}},{\"name\":\"Coverage.Types.area\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Coverage.Types.Shape\",\"Coverage.Types.area.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Shape\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Types.Shape\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.circle\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.rect\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Shape.empty\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}]}}}}}}}},\"uses\":[\"Mul\",\"Nat\",\"OfNat\",\"PUnit\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"Unit.unit\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"]},\"inductive\":null},{\"name\":\"Coverage.Types.defaultWeights\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Coverage.Types.Weights.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.2\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.4\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.4\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Weights.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Coverage.Types.Weights\",\"Coverage.Types.Weights.mk\"]},\"inductive\":null},{\"name\":\"Coverage.Types.isEven\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Nat.below\",\"Nat.brecOn\",\"PProd.mk\",\"Coverage.Types.isEven._f\",\"Coverage.Types.isOdd._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isOdd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"PUnit\",\"Bool.true\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\",\"Coverage.Types.isOdd\"]},\"inductive\":null},{\"name\":\"Coverage.Types.isOdd\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Nat.below\",\"Nat.brecOn\",\"PProd.mk\",\"Coverage.Types.isEven._f\",\"Coverage.Types.isOdd._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.isEven\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"PUnit\",\"Bool.false\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\",\"Coverage.Types.isEven\"]},\"inductive\":null},{\"name\":\"Coverage.Types.mapList\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.brecOn\",\"Coverage.Types.mapList._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":1}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.90\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.mapList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},\"borrow\":false},{\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}]}}}}}},\"uses\":[\"List\",\"List.cons\",\"List.nil\",\"Coverage.Types.mapList\"]},\"inductive\":null},{\"name\":\"Coverage.Types.treeSum\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.brecOn\",\"Coverage.Types.treeSum._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Coverage.Types.treeSum\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Coverage.Types.Tree\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Tree.leaf\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Coverage.Types.Tree.node\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Tree\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Unit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.treeSum\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"]},\"inductive\":null},{\"name\":\"Coverage.Types.twice\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\"]},\"inductive\":null},{\"name\":\"Coverage.Types.unbox\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Box\",\"Coverage.Types.Box.content\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"bvar\",\"index\":1}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Coverage.Types.Box\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Coverage.Types.Box\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}},\"uses\":[\"Coverage.Types.Box\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Char\",\"List\",\"Nat\",\"Ordering\",\"Unit\",\"instOrdNat\",\"Char.val\",\"List.below\",\"List.cons\",\"List.nil\",\"Ord.compare\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"UInt32.toNat\",\"LexLeanCollections.compareCodes.match_1\",\"LexLeanCollections.compareCodes.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.compareCodes._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_4\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Char\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Ordering.casesOn\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Prod\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Prod.casesOn\",\"Prod.mk\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"LexLeanCollections.iterate.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.lookupEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Option\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.insertElement\",\"List.foldl\",\"List.nil\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"LexLeanCollections.reachableFrom.match_1\",\"LexLeanCollections.reachableFrom.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Nat\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"List.cons\",\"List.ctorIdx\",\"List.nil\",\"List.rec\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.ctorIdx\",\"List.nil\",\"Nat.hasNotBit\",\"Unit.unit\",\"LexLeanCollections.reachableFrom._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.reachableFrom.match_4\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.removeElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.removeEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertEntry.match_1\",\"LexLeanCollections.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.topological._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.not\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"LexLeanCollections.graphSuccessors\",\"LexLeanCollections.removeElement\",\"List.all\",\"List.cons\",\"List.filter\",\"List.isEmpty\",\"List.reverse\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.reachableFrom.match_4\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.format\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Decimal.parse\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Decimal\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitAnd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitNot\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitOr\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.bitXor\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.shiftLeft\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.shiftRight\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedMultiplyInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt64\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instAddUInt64\",\"instHAdd\",\"instHSub\",\"instLEUInt64\",\"instOfNatNat\",\"instSubUInt64\",\"ite\",\"HAdd.hAdd\",\"HSub.hSub\",\"LE.le\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"UInt64.decLe\",\"UInt64.instOfNat\",\"LexLeanRuntime.divideMagnitudeInt64.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.divideMagnitudeInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"UInt64\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.instDecimalInt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.listIndex.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.listIndex.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"UInt64\",\"instAddUInt64\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLEUInt64\",\"instLTUInt64\",\"instOfNatNat\",\"instSubUInt64\",\"ite\",\"Bool.or\",\"Bool.true\",\"Decidable.decide\",\"HAdd.hAdd\",\"HSub.hSub\",\"LE.le\",\"LT.lt\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt64.decLe\",\"UInt64.decLt\",\"UInt64.instOfNat\",\"LexLeanRuntime.multiplyMagnitudeInt64.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.multiplyMagnitudeInt64.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"UInt64\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"PUnit.unit\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.rec\",\"Coverage.Boundary.Grove.settled\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.leaf\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.Grove.settled\",\"kind\":\"constructor\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Boundary.groveTags.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Boundary\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Except\",\"Int\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"Coverage.Boundary.Grove\",\"Coverage.Boundary.Grove.casesOn\",\"Coverage.Boundary.Grove.leaf\",\"Coverage.Boundary.Grove.node\",\"Coverage.Boundary.Grove.settled\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Main.options.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Main.options.match_3\",\"kind\":\"definition\",\"module\":\"Coverage.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.countdown._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Eq.refl\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.exprSize.match_1\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.exprSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.casesOn\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.forestSize.match_1\",\"Coverage.Syntax.Rose.below_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.forestSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Syntax.Rose\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.prune._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_literal\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.prune._proof_2\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.prune_plus\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_literal\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate._proof_2\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"Eq.ndrec\",\"Eq.symm\",\"LT.lt\",\"Coverage.Recur.reassociate_plus\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reassociate.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Eq\",\"Nat\",\"Eq.refl\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.casesOn\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.reduce._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Rose\",\"Coverage.Recur.roseSize.match_1\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.roseSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.casesOn\",\"Coverage.Syntax.Rose.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.search._unary\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"WellFounded.Nat.fix\",\"Coverage.Recur.countdown.match_1\",\"Coverage.Recur.search._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"String\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.statementSize.match_1\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.casesOn\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Recur.statementsSize.match_1\",\"Coverage.Syntax.Expr.below_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.statementsSize.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Coverage.Syntax.Stmt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.weight._f\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Syntax.Term\",\"Coverage.Recur.weight.match_1\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.weight.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.casesOn\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.below_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.block\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Expr.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Expr.brecOn_1.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PUnit\",\"String\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.literal\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.plus\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.rec_1\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.below_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn_1\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.brecOn_1.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PUnit\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.rec_1\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.assign\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PUnit\",\"String\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.rec\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.sequence\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.below\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.literal\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.plus\",\"kind\":\"constructor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Box.content\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Box\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Box.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.x\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Point\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Point.y\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Point\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rec\",\"Coverage.Types.Shape.rect\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.circle\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.empty\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Shape.rect\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.below\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.brecOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.brecOn.go\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.casesOn\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.leaf\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.node\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.rec\",\"kind\":\"recursor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Weights.mk\",\"kind\":\"constructor\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Weights.scale\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Coverage.Types.Weights\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.area.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Coverage.Types.Shape\",\"Coverage.Types.Shape.casesOn\",\"Coverage.Types.Shape.circle\",\"Coverage.Types.Shape.empty\",\"Coverage.Types.Shape.rect\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isEven._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Unit\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"Nat.zero\",\"Coverage.Types.isEven.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isEven.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Nat.casesOn\",\"Nat.succ\",\"Nat.zero\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.isOdd._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"PProd\",\"Unit\",\"Bool.false\",\"Nat.below\",\"Nat.succ\",\"Nat.zero\",\"Coverage.Types.isEven.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.mapList._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"List.below\",\"List.cons\",\"List.nil\",\"Coverage.Types.mapList.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.mapList.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.treeSum._f\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.treeSum.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.treeSum.match_1\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.casesOn\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.countdown_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.prune_plus._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.natCast_nonneg\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_literal._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reassociate_plus._proof_1_35\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.natCast_nonneg\",\"Int.sub_nonneg_of_le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Coverage.Recur.weight\",\"Coverage.Syntax.Term\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"GT.gt\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_nonneg\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Nat.lt_or_gt_of_ne\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_2\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.reduce_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Coverage.Recur.0.Coverage.Recur.search_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.natCast_add\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.combo_sat'\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.coordinate_eval_3\",\"Lean.Omega.LinearCombo.coordinate_eval_4\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.countdown._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"Coverage.Recur.countdown_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.reduce._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Coverage.Recur.reduce_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Recur.search._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Coverage.Recur\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Coverage.Recur.search_decreases\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Expr.brecOn_1.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Expr.rec_1\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Rose.brecOn_1.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"PProd\",\"PUnit\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Rose\",\"Coverage.Syntax.Rose.below\",\"Coverage.Syntax.Rose.below_1\",\"Coverage.Syntax.Rose.node\",\"Coverage.Syntax.Rose.rec_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Stmt.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"PProd\",\"PUnit\",\"String\",\"List.cons\",\"List.nil\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Expr\",\"Coverage.Syntax.Stmt\",\"Coverage.Syntax.Expr.below\",\"Coverage.Syntax.Expr.below_1\",\"Coverage.Syntax.Expr.block\",\"Coverage.Syntax.Expr.literal\",\"Coverage.Syntax.Expr.plus\",\"Coverage.Syntax.Stmt.assign\",\"Coverage.Syntax.Stmt.below\",\"Coverage.Syntax.Stmt.rec\",\"Coverage.Syntax.Stmt.sequence\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Syntax.Term.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Syntax\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Syntax.Term\",\"Coverage.Syntax.Term.below\",\"Coverage.Syntax.Term.literal\",\"Coverage.Syntax.Term.plus\",\"Coverage.Syntax.Term.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Coverage.Types.Tree.brecOn.go\",\"kind\":\"definition\",\"module\":\"Coverage.Types\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PProd\",\"PUnit\",\"PProd.mk\",\"PUnit.unit\",\"Coverage.Types.Tree\",\"Coverage.Types.Tree.below\",\"Coverage.Types.Tree.leaf\",\"Coverage.Types.Tree.node\",\"Coverage.Types.Tree.rec\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Char\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int16\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int32\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int64\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int8\",\"kind\":\"inductive\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Neg\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"String\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ToString\",\"kind\":\"inductive\",\"module\":\"Init.Data.ToString.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt16\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt64\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"bne\",\"kind\":\"definition\",\"module\":\"Init.Core\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instAddUInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqInt32\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqOrdering\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqString\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt16\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdBool\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubUInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringInt\",\"kind\":\"definition\",\"module\":\"Init.Data.ToString.Extra\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringInt8\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instToStringUInt32\",\"kind\":\"definition\",\"module\":\"Init.Data.ToString.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.decide\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instAdd\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instMul\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instNegInt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"Int.tdiv\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.tmod\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.DivMod.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int16.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.instNeg\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.instNeg\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int64.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.land\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.toInt\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int8.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.all\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.drop\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.filterTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.isEmpty\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.mapTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.reverse\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.takeTR\",\"kind\":\"axiom\",\"module\":\"Init.Data.List.Impl\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.div\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.mod\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.isSome\",\"kind\":\"definition\",\"module\":\"Init.Data.Option.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.eq\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.gt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"String.fromUTF8?\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.intercalate\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.isEmpty\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.length\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Length\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.splitOn\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Legacy\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toInt?\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Search\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.String.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"String.toUTF8\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt16.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.decLe\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.toInt64\",\"kind\":\"definition\",\"module\":\"Init.Data.SInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt64.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.UInt\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"61bc88661e5d1048dfc867a9b847049b2c9eeceed3cb0f4da5fc8437c0fab574","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0.lean index 3e8c56279..9d6a9660a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[(.list .nat), (.list (.adt 0)), (.list (.pair .string .int)), (.option (.adt 0)), (.list (.pair .nat (.adt 0)))], [(.list (.pair .nat .int))], [(.result (.adt 0) .nat)]] }, @@ -373,24 +373,24 @@ def entryValue (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledg /-- The entry's observation. -/ def denoteEntry (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryFits g ledger picks spare) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryValue g ledger picks spare)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryFits g ledger picks spare) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryValue g ledger picks spare)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) : Prop := (__inv_2 g ∧ (__inv_13 ledger ∧ (__inv_14 picks ∧ (__inv_15 spare ∧ _root_.True)))) -theorem entry (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) : _root_.LexLeanPreservation.RunConv __prog 18 [(__enc_0 g), (__enc_1 ledger), ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) picks), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool))) spare)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry g ledger picks spare) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_13 ledger then (if __valid_14 picks then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_13 ledger then (if __valid_14 picks then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_2 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_2 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_14 picks then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_14 picks then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_13 ledger) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_13 ledger)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_14 picks) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_14 picks)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g ledger picks spare else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_15 spare) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_15 spare)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)))) (__rel_0 g ledger picks spare)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryFits])) +theorem entry (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) : _root_.LexLeanPreservation.RunConv __prog 18 [(__enc_0 g), (__enc_1 ledger), ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) picks), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool))) spare)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry g ledger picks spare) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_13 ledger then (if __valid_14 picks then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_13 ledger then (if __valid_14 picks then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_2 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_2 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_14 picks then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_14 picks then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_13 ledger) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_13 ledger)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_15 spare then __fits_0 g ledger picks spare else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_15 spare then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_14 picks) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_14 picks)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g ledger picks spare else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair __enc_1 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Boundary.groveRoot g ledger picks spare))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_15 spare) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_15 spare)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)))) (__rel_0 g ledger picks spare)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryFits])) -theorem entry_accepts (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.accepts g ledger picks spare) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry g ledger picks spare = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denote g ledger picks spare) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denote +theorem entry_accepts (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.accepts g ledger picks spare) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry g ledger picks spare = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denote g ledger picks spare) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denote simp only [_root_.if_true, (__viff_2 g).mpr __h.1, (__viff_13 ledger).mpr __h.2.1, (__viff_14 picks).mpr __h.2.2.1, (__viff_15 spare).mpr __h.2.2.2.1] cases __fits_0 g ledger picks spare <;> rfl -theorem entry_refuses (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.accepts g ledger picks spare) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry g ledger picks spare = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryValue +theorem entry_refuses (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.accepts g ledger picks spare) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry g ledger picks spare = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryValue cases __c0 : __valid_2 g · simp · cases __c1 : __valid_13 ledger @@ -401,4 +401,4 @@ theorem entry_refuses (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Bounda · simp · exact _root_.absurd ⟨(__viff_2 g).mp __c0, (__viff_13 ledger).mp __c1, (__viff_14 picks).mp __c2, (__viff_15 spare).mp __c3, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/Compose/RustStd.lex.tex similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/Compose/RustStd.lex.tex index 3a5abf3af..f7de79482 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/Compose/RustStd.lex.tex @@ -1,75 +1,75 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_0 : @2059 := @2058 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_0 : @2059 := @2058 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_0 : @2081 := @2080 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_0 : @2081 := @2080 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_1 : @2103 := @2102 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_1], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_1 : @2103 := @2102 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_3 : @2125 := @2124 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_3], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_3 : @2125 := @2124 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_3], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_4 : @2147 := @2146 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_4], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_4 : @2147 := @2146 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_4], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_2 : @2169 := @2168 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_2], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_2 : @2169 := @2168 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_1 : @2176 := @2362 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_1 : @2176 := @2362 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.root : @3729 := @3730 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.root : @3729 := @3730 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.flags @3 := Coverage.Boundary.Grove @4 := #0 -@5 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__enc_0 +@5 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -82,7 +82,7 @@ @16 := fun (__v : @3) => @15 @17 := List.{0} @18 := @17 @3 -@19 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__items_0 +@19 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__items_0 @20 := @19 @4 @21 := LexLeanPreservation.Rust.WTAll @22 := @21 @0 @@ -92,7 +92,7 @@ @27 := fun (__v : @18) => @26 @28 := Option.{0} @29 := @28 @3 -@30 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__aux_1 +@30 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__aux_1 @31 := @30 @4 @32 := LexLeanTarget.TargetSyntax.Ty.option @33 := @32 @10 @@ -103,7 +103,7 @@ @39 := @38 @37 @40 := @39 @3 @41 := @17 @40 -@42 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__items_3 +@42 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__items_3 @43 := @42 @4 @44 := LexLeanTarget.TargetSyntax.Ty.nat @45 := LexLeanTarget.TargetSyntax.Ty.pair @@ -112,14 +112,14 @@ @49 := @24 @43 @47 @50 := fun (__v : @41) => @49 @53 := Except.{0, 0} @37 @3 -@54 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__aux_4 +@54 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__aux_4 @55 := @54 @4 @56 := LexLeanTarget.TargetSyntax.Ty.result @57 := @56 @10 @58 := @57 @44 @60 := @13 @55 @58 @61 := fun (__v : @53) => @60 -@62 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__aux_2 +@62 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__aux_2 @65 := @13 (@62 @4) @47 @66 := fun (__v : @40) => @65 @67 := #7 @@ -202,7 +202,7 @@ @214 := @213 @67 @216 := @13 @78 @80 @217 := LexLeanPreservation.ListEnc.enc -@218 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__L_0 +@218 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__L_0 @220 := @217 @3 @218 @221 := @220 @68 @222 := @79 @10 @@ -369,10 +369,10 @@ @577 := @576 @70 @579 := @13 @313 @318 @580 := LexLeanPreservation.OptEnc.enc -@581 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__O_1 +@581 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__O_1 @583 := @580 @3 @581 @584 := @583 @71 -@585 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__L_3 +@585 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__L_3 @587 := @217 @40 @585 @588 := @587 @73 @589 := @79 @47 @@ -1156,7 +1156,7 @@ @4 @2169 := (__v : @40) -> @65 @2170 := Coverage.Boundary.Ledger -@2171 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.__enc_1 +@2171 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.__enc_1 @2172 := @2171 @4 @2173 := @8 @1328 @2176 := (__s : @2170) -> @13 @2172 @2173 @@ -1244,9 +1244,9 @@ @2358 := @2353 @2313 @2361 := @13 (@1112 @2192) @2173 @2362 := fun (__s : @2170) => @2358 -@2364 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_0 @71 +@2364 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_0 @71 @2365 := @2171 @73 -@2367 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_1 @73 +@2367 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_1 @73 @2368 := @28 @190 @2369 := LexLeanPreservation.encOption @2370 := @2369 @190 @@ -1386,7 +1386,7 @@ @2644 := LexLeanTarget.TargetSyntax.Function.mk @2634 @626 @2635 @2639 @2649 := List.getD.{0} @2630 @2632 @2633 @2644 @2653 := fun (__e_n : @37) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.root @4 @2633 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.root @4 @2633 @2654 := @728 @2460 @2655 := @2459 @71 @2657 := @13 @2655 @69 @@ -1519,12 +1519,12 @@ @2878 := @2873 @2826 @2879 := @663 @2605 @2880 := @2879 @2869 -@2881 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denoteEntry +@2881 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denoteEntry @2885 := @2881 @71 @73 @69 @72 -@2886 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryFits +@2886 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryFits @2890 := @2886 @71 @73 @69 @72 -@2895 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entryValue @71 @73 @69 @72 -@2900 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entry @71 @73 @69 @72 +@2895 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entryValue @71 @73 @69 @72 +@2900 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entry @71 @73 @69 @72 @2901 := Ne.{1} @2902 := LexLeanPreservation.Obs @2903 := @2901 @2902 @@ -1811,10 +1811,10 @@ @3558 := @3121 @2874 @4 @3559 := @3556 @3558 @3561 := @2990 (fun (ro : @2989) => @3559) -@3562 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.accepts +@3562 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.accepts @3566 := @3562 @71 @73 @69 @72 @3567 := LexLeanPreservation.someObs -@3568 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.denote +@3568 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.denote @3573 := @3567 (@3568 @71 @73 @69 @72) @3575 := LexLeanPreservation.Obs.value @1632 @3576 := Not @@ -1840,13 +1840,13 @@ @3619 := Eq.subst.{1} @3623 := @3562 @68 @70 @71 @73 @3624 := @3576 @3623 -@3630 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entry_accepts @67 @68 @70 @71 @4 +@3630 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entry_accepts @67 @68 @70 @71 @4 @3635 := @3567 (@3568 @67 @68 @70 @71) @3640 := @3608 (@3531 @69) (@3534 @69) @72 @3642 := fun (__e_o : @2902) => @3616 @73 @3645 := @3619 @2902 @3642 @3459 @3649 := fun (__e_h : @3623) => @3645 @3635 @3630 @3640 -@3655 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.entry_refuses @67 @68 @70 @71 @4 +@3655 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.entry_refuses @67 @68 @70 @71 @4 @3659 := fun (__e_h : @3624) => @3645 @3575 @3655 @3640 @3660 := And.intro @3663 := @3623 -> @3310 @3635 @69 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/RustStd.lean index 02f13dd85..0b6dfd385 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -177,4 +177,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1.lean similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1.lean index ad4d4f071..3b3784ecb 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -89,26 +89,26 @@ def entryValue (m : (List (Prod String Nat))) (k : String) (v : Nat) : _root_.Le /-- The entry's observation. -/ def denoteEntry (m : (List (Prod String Nat))) (k : String) (v : Nat) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryFits m k v) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryValue m k v)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryFits m k v) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryValue m k v)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (m : (List (Prod String Nat))) (k : String) (v : Nat) : Prop := (__inv_8 m ∧ _root_.True) -theorem entry (m : (List (Prod String Nat))) (k : String) (v : Nat) : _root_.LexLeanPreservation.RunConv __prog 10 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.string k), (_root_.LexLeanTarget.TargetSyntax.Value.nat v)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry m k v) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 m k v else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat))))))))) (Coverage.Colls.mapOps m k v))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_8 m) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_8 m)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (__rel_0 m k v)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryFits])) +theorem entry (m : (List (Prod String Nat))) (k : String) (v : Nat) : _root_.LexLeanPreservation.RunConv __prog 10 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.string k), (_root_.LexLeanTarget.TargetSyntax.Value.nat v)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry m k v) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 m k v else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat))))))))) (Coverage.Colls.mapOps m k v))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_8 m) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_8 m)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (__rel_0 m k v)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryFits])) -theorem entry_accepts (m : (List (Prod String Nat))) (k : String) (v : Nat) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.accepts m k v) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry m k v = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denote m k v) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denote +theorem entry_accepts (m : (List (Prod String Nat))) (k : String) (v : Nat) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.accepts m k v) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry m k v = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denote m k v) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denote simp only [_root_.if_true, (__viff_8 m).mpr __h.1] cases __fits_0 m k v <;> rfl -theorem entry_refuses (m : (List (Prod String Nat))) (k : String) (v : Nat) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.accepts m k v) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry m k v = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryValue +theorem entry_refuses (m : (List (Prod String Nat))) (k : String) (v : Nat) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.accepts m k v) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry m k v = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryValue cases __c0 : __valid_8 m · simp · exact _root_.absurd ⟨(__viff_8 m).mp __c0, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/Compose/RustStd.lex.tex index c33de98c6..9f15cd712 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.root : @1520 := @1521 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.root : @1520 := @1521 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.flags @3 := String @4 := Nat @5 := Prod.{0, 0} @@ -249,7 +249,7 @@ @438 := LexLeanTarget.TargetSyntax.Function.mk @427 @428 @429 @433 @443 := List.getD.{0} @423 @425 @426 @438 @447 := fun (__e_n : @4) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.root @29 @426 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.root @29 @426 @448 := LexLeanPreservation.Rust.WTL @456 := {p : @30} -> {c : @31} -> {A : @32} -> @448 @35 @37 @29 @392 @428 @458 := LexLeanPreservation.Rust.wtl_nil @0 @@ -390,12 +390,12 @@ @724 := @718 @666 @725 := @473 @399 @726 := @725 @714 -@727 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denoteEntry +@727 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denoteEntry @730 := @727 @10 @35 @37 -@731 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryFits +@731 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryFits @734 := @731 @10 @35 @37 -@738 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entryValue @10 @35 @37 -@742 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entry @10 @35 @37 +@738 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entryValue @10 @35 @37 +@742 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entry @10 @35 @37 @743 := Bool @744 := Ne.{1} @745 := LexLeanPreservation.Obs @@ -658,10 +658,10 @@ @1362 := @966 @720 @29 @1363 := @1360 @1362 @1365 := @835 (fun (ro : @834) => @1363) -@1366 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.accepts +@1366 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.accepts @1369 := @1366 @10 @35 @37 @1370 := LexLeanPreservation.someObs -@1371 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.denote +@1371 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.denote @1375 := @1370 (@1371 @10 @35 @37) @1378 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1379 := Not @@ -687,13 +687,13 @@ @1419 := Eq.subst.{1} @1422 := @1366 @99 @106 @10 @1423 := @1379 @1422 -@1428 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entry_accepts @119 @99 @106 @29 +@1428 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entry_accepts @119 @99 @106 @29 @1432 := @1370 (@1371 @119 @99 @106) @1437 := @1408 (@1335 @35) (@1338 @35) @37 @1439 := fun (__e_o : @745) => @1416 @10 @1442 := @1419 @745 @1439 @1265 @1446 := fun (__e_h : @1422) => @1442 @1432 @1428 @1437 -@1451 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.entry_refuses @119 @99 @106 @29 +@1451 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.entry_refuses @119 @99 @106 @29 @1455 := fun (__e_h : @1423) => @1442 @1378 @1451 @1437 @1456 := And.intro @1459 := @1422 -> @1133 @1432 @35 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/RustStd.lean index 692ab55d2..e290a0f1c 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -110,4 +110,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10.lean index f50b9f39f..ee038aac0 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Nat) (b : Nat) : _root_.LexLeanPreservation.Obs := theorem root (a : Nat) (b : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Main.natOps a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustCore.lex.tex index 6330ed302..e5d716729 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.root : @914 := @915 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -82,7 +82,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -193,12 +193,12 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.__fits_0 @326 := @324 @4 @15 @330 := @5 (Coverage.Main.natOps @4 @15) -@333 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.root @4 @15 +@333 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.root @4 @15 @334 := Bool @335 := Ne.{1} @336 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustStd.lex.tex index b4f587e3a..a0fb990b0 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.root : @914 := @915 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -82,7 +82,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -193,12 +193,12 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.__fits_0 @326 := @324 @4 @15 @330 := @5 (Coverage.Main.natOps @4 @15) -@333 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.root @4 @15 +@333 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.root @4 @15 @334 := Bool @335 := Ne.{1} @336 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustCore.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustCore.lean index 81d43cfdc..d7b1a69bd 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustStd.lean index 8411ec452..d07b2f2b1 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11.lean index 49d78abbc..5d6726059 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int) (b : Int) : _root_.LexLeanPreservation.Obs := theorem root (a : Int) (b : Int) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.int b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) (_root_.LexLeanTarget.TargetSyntax.Value.int (Coverage.Main.intOps a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustCore.lex.tex index 315c85662..1fed27286 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.root : @915 := @916 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.root : @915 := @916 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.flags @3 := Int @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.int @@ -83,7 +83,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.root @17 @73 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,12 +194,12 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.denote +@322 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.__fits_0 +@325 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.__fits_0 @327 := @325 @4 @15 @331 := @5 (Coverage.Main.intOps @4 @15) -@334 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.root @4 @15 +@334 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.root @4 @15 @335 := Bool @336 := Ne.{1} @337 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustStd.lex.tex index a51e79dcf..8081eb178 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.root : @915 := @916 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.root : @915 := @916 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.flags @3 := Int @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.int @@ -83,7 +83,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.root @17 @73 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,12 +194,12 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.denote +@322 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.__fits_0 +@325 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.__fits_0 @327 := @325 @4 @15 @331 := @5 (Coverage.Main.intOps @4 @15) -@334 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.root @4 @15 +@334 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.root @4 @15 @335 := Bool @336 := Ne.{1} @337 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustCore.lean index 5764458c1..5f6871455 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustStd.lean index df2f71a23..2d46e6d7d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12.lean index 1f443097b..e300cfce6 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat], [.nat, .nat], []] }], functions := [ @@ -51,4 +51,4 @@ def denote (w : Nat) (h : Nat) : _root_.LexLeanPreservation.Obs := theorem root (w : Nat) (h : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat w), (_root_.LexLeanTarget.TargetSyntax.Value.nat h)] (_root_.LexLeanPreservation.Rel (__fits_0 w h) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Main.shapes w h))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 w h) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustCore.lex.tex index 9cbfa7aad..00fa03ad4 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustCore.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.__wt_0 : @16 := @482 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.root : @1157 := @1158 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.root : @1157 := @1158 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.flags @3 := Coverage.Types.Shape @4 := #0 -@6 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.__enc_0 @4 +@6 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -293,7 +293,7 @@ @514 := LexLeanTarget.TargetSyntax.Function.mk @504 @65 @505 @509 @519 := List.getD.{0} @501 @503 @9 @514 @523 := fun (__e_n : @24) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.root @4 @9 @524 := @379 @61 @525 := @204 @61 @530 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @525 @207 @@ -315,12 +315,12 @@ @565 := @557 @68 @568 := (h : @202) -> (hs : @229) -> @388 @365 @570 := @565 @483 @536 -@571 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.denote +@571 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.denote @573 := @571 @27 @29 -@574 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.__fits_0 +@574 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.__fits_0 @576 := @574 @27 @29 @580 := @18 (Coverage.Main.shapes @27 @29) -@583 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.root @27 @29 +@583 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.root @27 @29 @584 := Bool @585 := Ne.{1} @586 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustStd.lex.tex index 18a1d8968..3ca88eb5a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.__wt_0 : @16 := @482 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.root : @1157 := @1158 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.root : @1157 := @1158 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.flags @3 := Coverage.Types.Shape @4 := #0 -@6 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.__enc_0 @4 +@6 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -293,7 +293,7 @@ @514 := LexLeanTarget.TargetSyntax.Function.mk @504 @65 @505 @509 @519 := List.getD.{0} @501 @503 @9 @514 @523 := fun (__e_n : @24) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.root @4 @9 @524 := @379 @61 @525 := @204 @61 @530 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @525 @207 @@ -315,12 +315,12 @@ @565 := @557 @68 @568 := (h : @202) -> (hs : @229) -> @388 @365 @570 := @565 @483 @536 -@571 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.denote +@571 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.denote @573 := @571 @27 @29 -@574 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.__fits_0 +@574 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.__fits_0 @576 := @574 @27 @29 @580 := @18 (Coverage.Main.shapes @27 @29) -@583 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.root @27 @29 +@583 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.root @27 @29 @584 := Bool @585 := Ne.{1} @586 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustCore.lean index e63042723..10239e821 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -39,4 +39,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustStd.lean index e4b2c7e27..6a9cb0442 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -39,4 +39,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13.lean index b404a5dbf..73e41df85 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [(.adt 0), .nat, (.adt 0)]] }], functions := [ @@ -52,4 +52,4 @@ def denote (n : Nat) : _root_.LexLeanPreservation.Obs := theorem root (n : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] (_root_.LexLeanPreservation.Rel (__fits_0 n) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Main.treeTotal n))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 n) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/Compose/RustStd.lex.tex index 0841097c9..8bdaa53bb 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.__wt_0 : @520 := @519 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.root : @1152 := @1153 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.root : @1152 := @1153 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.flags @3 := Coverage.Types.Tree @4 := #0 -@5 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.__enc_0 +@5 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -307,7 +307,7 @@ @553 := LexLeanTarget.TargetSyntax.Function.mk @543 @22 @544 @548 @558 := List.getD.{0} @540 @542 @9 @553 @562 := fun (__e_n : @56) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.root @4 @9 @563 := @296 @521 @572 := {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @392 @27) -> (hs : @141) -> @53 (@395 @67) @253 @@ -331,12 +331,12 @@ @604 := @598 @52 @605 := @53 @526 @606 := @605 @594 -@607 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.denote +@607 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.denote @608 := @607 @29 -@609 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.__fits_0 +@609 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.__fits_0 @610 := @609 @29 @613 := @192 (Coverage.Main.treeTotal @29) -@615 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.root @29 +@615 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.root @29 @616 := Bool @617 := Ne.{1} @618 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/RustStd.lean index 16f9a1b2d..3d8d010aa 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -39,4 +39,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14.lean index 31d9bfecc..7b82fdcd5 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat]] }, @@ -65,4 +65,4 @@ def denote (a : Nat) (b : Nat) : _root_.LexLeanPreservation.Obs := theorem root (a : Nat) (b : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat) (Coverage.Main.records a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustCore.lex.tex index 2fbf028ee..5f23cc486 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustCore.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_0 : @16 := @440 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_1 : @449 := @632 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_1], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_2 : @640 := @821 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_2], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.root : @1560 := @1561 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.root : @1560 := @1561 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.flags @3 := Coverage.Types.Point @4 := #0 -@6 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_0 @4 +@6 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -253,7 +253,7 @@ @439 := @13 (@404 @76) @10 @440 := fun (__s : @3) => @436 @442 := Coverage.Types.Box @27 -@444 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_1 @4 +@444 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_1 @4 @445 := 1 @446 := @8 @445 @449 := (__s : @442) -> @13 @444 @446 @@ -337,7 +337,7 @@ @631 := @13 (@404 @467) @446 @632 := fun (__s : @442) => @628 @633 := Coverage.Types.Weights -@635 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_2 @4 +@635 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_2 @4 @636 := 2 @637 := @8 @636 @640 := (__s : @633) -> @13 @635 @637 @@ -451,7 +451,7 @@ @864 := LexLeanTarget.TargetSyntax.Function.mk @854 @77 @855 @859 @869 := List.getD.{0} @851 @853 @9 @864 @873 := fun (__e_n : @27) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.root @4 @9 @874 := @185 @826 @875 := @21 @117 @876 := @13 @875 @@ -504,13 +504,13 @@ @963 := @958 @921 @964 := @107 @833 @965 := @964 @81 -@966 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.denote +@966 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.denote @968 := @966 @30 @32 -@969 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__fits_0 +@969 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__fits_0 @971 := @969 @30 @32 @974 := Coverage.Main.records @30 @32 @980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 -@983 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.root @30 @32 +@983 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.root @30 @32 @984 := Bool @985 := Ne.{1} @986 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustStd.lex.tex index 2fcbc374c..38422ac78 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustStd.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_0 : @16 := @440 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_1 : @449 := @632 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_2 : @640 := @821 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_2], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.root : @1560 := @1561 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.root : @1560 := @1561 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.flags @3 := Coverage.Types.Point @4 := #0 -@6 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_0 @4 +@6 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -253,7 +253,7 @@ @439 := @13 (@404 @76) @10 @440 := fun (__s : @3) => @436 @442 := Coverage.Types.Box @27 -@444 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_1 @4 +@444 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_1 @4 @445 := 1 @446 := @8 @445 @449 := (__s : @442) -> @13 @444 @446 @@ -337,7 +337,7 @@ @631 := @13 (@404 @467) @446 @632 := fun (__s : @442) => @628 @633 := Coverage.Types.Weights -@635 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__enc_2 @4 +@635 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__enc_2 @4 @636 := 2 @637 := @8 @636 @640 := (__s : @633) -> @13 @635 @637 @@ -451,7 +451,7 @@ @864 := LexLeanTarget.TargetSyntax.Function.mk @854 @77 @855 @859 @869 := List.getD.{0} @851 @853 @9 @864 @873 := fun (__e_n : @27) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.root @4 @9 @874 := @185 @826 @875 := @21 @117 @876 := @13 @875 @@ -504,13 +504,13 @@ @963 := @958 @921 @964 := @107 @833 @965 := @964 @81 -@966 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.denote +@966 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.denote @968 := @966 @30 @32 -@969 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.__fits_0 +@969 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.__fits_0 @971 := @969 @30 @32 @974 := Coverage.Main.records @30 @32 @980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 -@983 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.root @30 @32 +@983 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.root @30 @32 @984 := Bool @985 := Ne.{1} @986 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustCore.lean index 8cf80391f..a3e97b839 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -51,4 +51,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustStd.lean index 969183c8d..f603fe9e7 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -51,4 +51,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15.lean index 235741f88..4facf77cb 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (v : (Option Nat)) (r : (Except Bool Nat)) : _root_.LexLeanPreservati theorem root (v : (Option Nat)) (r : (Except Bool Nat)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) v), ((_root_.LexLeanPreservation.encExcept _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) r)] (_root_.LexLeanPreservation.Rel (__fits_0 v r) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Main.options v r))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 v r) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustCore.lex.tex similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustCore.lex.tex index a86d02c03..46c035430 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.root : @1260 := @1261 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.root : @1260 := @1261 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.flags @3 := Nat @4 := Option.{0} @5 := @4 @3 @@ -238,7 +238,7 @@ @426 := LexLeanTarget.TargetSyntax.Function.mk @415 @416 @417 @421 @431 := List.getD.{0} @412 @414 @402 @426 @435 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.root @15 @402 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.root @15 @402 @436 := LexLeanPreservation.Rust.WTL @444 := {p : @16} -> {c : @17} -> {A : @18} -> @436 @6 @23 @15 @387 @416 @446 := LexLeanPreservation.Rust.wtl_nil @0 @@ -348,12 +348,12 @@ @655 := @649 @597 @656 := @461 @392 @657 := @656 @645 -@658 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.denote +@658 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.denote @660 := @658 @6 @23 -@661 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.__fits_0 +@661 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.__fits_0 @663 := @661 @6 @23 @667 := @7 (Coverage.Main.options @6 @23) -@670 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.root @6 @23 +@670 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.root @6 @23 @671 := Ne.{1} @672 := LexLeanPreservation.Obs @673 := @671 @672 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustStd.lex.tex similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustStd.lex.tex index 13d3fa35f..16f588a91 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.root : @1260 := @1261 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.root : @1260 := @1261 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.flags @3 := Nat @4 := Option.{0} @5 := @4 @3 @@ -238,7 +238,7 @@ @426 := LexLeanTarget.TargetSyntax.Function.mk @415 @416 @417 @421 @431 := List.getD.{0} @412 @414 @402 @426 @435 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.root @15 @402 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.root @15 @402 @436 := LexLeanPreservation.Rust.WTL @444 := {p : @16} -> {c : @17} -> {A : @18} -> @436 @6 @23 @15 @387 @416 @446 := LexLeanPreservation.Rust.wtl_nil @0 @@ -348,12 +348,12 @@ @655 := @649 @597 @656 := @461 @392 @657 := @656 @645 -@658 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.denote +@658 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.denote @660 := @658 @6 @23 -@661 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.__fits_0 +@661 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.__fits_0 @663 := @661 @6 @23 @667 := @7 (Coverage.Main.options @6 @23) -@670 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.root @6 @23 +@670 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.root @6 @23 @671 := Ne.{1} @672 := LexLeanPreservation.Obs @673 := @671 @672 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustCore.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustCore.lean index 2dc70b986..334776d48 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustStd.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustStd.lean index a2900a27f..f0d5d1ca1 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16.lean index fe8049d58..968b17c7f 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (n : Nat) : _root_.LexLeanPreservation.Obs := theorem root (n : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] (_root_.LexLeanPreservation.Rel (__fits_0 n) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encExcept _root_.LexLeanPreservation.encUnit _root_.LexLeanTarget.TargetSyntax.Value.nat)) (Coverage.Main.builders n))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 n) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustCore.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustCore.lex.tex index 67b0f955d..ed24427ac 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.root : @844 := @845 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.root : @844 := @845 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.root @17 @60 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,9 +158,9 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.denote +@271 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.__fits_0 +@273 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.__fits_0 @274 := @273 @4 @276 := Coverage.Main.builders @4 @277 := Option.{0} @@ -171,7 +171,7 @@ @286 := LexLeanPreservation.encUnit @291 := LexLeanPreservation.encExcept @279 @3 @286 @5 @297 := LexLeanPreservation.encPair @278 @282 @285 @291 @276 -@299 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.root @4 +@299 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.root @4 @300 := Bool @301 := Ne.{1} @302 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustStd.lex.tex index 6949fcfff..9f19a2b6e 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.root : @844 := @845 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.root : @844 := @845 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.root @17 @60 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,9 +158,9 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.denote +@271 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.__fits_0 +@273 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.__fits_0 @274 := @273 @4 @276 := Coverage.Main.builders @4 @277 := Option.{0} @@ -171,7 +171,7 @@ @286 := LexLeanPreservation.encUnit @291 := LexLeanPreservation.encExcept @279 @3 @286 @5 @297 := LexLeanPreservation.encPair @278 @282 @285 @291 @276 -@299 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.root @4 +@299 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.root @4 @300 := Bool @301 := Ne.{1} @302 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustCore.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustCore.lean index 4a930ffff..d70cb991a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustStd.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustStd.lean index 6a1df6c56..47a3fd589 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17.lean index 2c7dd7943..798144115 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (p : (Prod Nat Bool)) : _root_.LexLeanPreservation.Obs := theorem root (p : (Prod Nat Bool)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) p)] (_root_.LexLeanPreservation.Rel (__fits_0 p) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) (Coverage.Main.pairs p))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 p) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustCore.lex.tex index e0b262c93..b3d6023f7 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.root : @1045 := @1046 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.root : @1045 := @1046 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.flags @3 := Nat @4 := Bool @5 := Prod.{0, 0} @@ -186,7 +186,7 @@ @311 := LexLeanTarget.TargetSyntax.Function.mk @300 @301 @302 @306 @316 := List.getD.{0} @297 @299 @286 @311 @320 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.root @22 @286 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.root @22 @286 @321 := LexLeanPreservation.Rust.WTL @329 := {p : @23} -> {c : @24} -> {A : @25} -> @321 @29 @8 @22 @281 @301 @331 := LexLeanPreservation.Rust.wtl_nil @0 @@ -265,13 +265,13 @@ @488 := @482 @345 @489 := @346 @284 @490 := @489 @478 -@491 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.denote +@491 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.denote @492 := @491 @8 -@493 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.__fits_0 +@493 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.__fits_0 @494 := @493 @8 @496 := Coverage.Main.pairs @8 @501 := @11 @4 @3 @10 @9 @496 -@503 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.root @8 +@503 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.root @8 @504 := Ne.{1} @505 := LexLeanPreservation.Obs @506 := @504 @505 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustStd.lex.tex index e2f4e40ec..589dd2f18 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.root : @1045 := @1046 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.root : @1045 := @1046 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.flags @3 := Nat @4 := Bool @5 := Prod.{0, 0} @@ -186,7 +186,7 @@ @311 := LexLeanTarget.TargetSyntax.Function.mk @300 @301 @302 @306 @316 := List.getD.{0} @297 @299 @286 @311 @320 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.root @22 @286 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.root @22 @286 @321 := LexLeanPreservation.Rust.WTL @329 := {p : @23} -> {c : @24} -> {A : @25} -> @321 @29 @8 @22 @281 @301 @331 := LexLeanPreservation.Rust.wtl_nil @0 @@ -265,13 +265,13 @@ @488 := @482 @345 @489 := @346 @284 @490 := @489 @478 -@491 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.denote +@491 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.denote @492 := @491 @8 -@493 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.__fits_0 +@493 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.__fits_0 @494 := @493 @8 @496 := Coverage.Main.pairs @8 @501 := @11 @4 @3 @10 @9 @496 -@503 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.root @8 +@503 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.root @8 @504 := Ne.{1} @505 := LexLeanPreservation.Obs @506 := @504 @505 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustCore.lean similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustCore.lean index 02612c762..404c046dd 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustStd.lean similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustStd.lean index 0ba46b394..81999609a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18.lean index eb0fb0b3e..511ac9606 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -70,4 +70,4 @@ def denote (base : Nat) (offset : Nat) : _root_.LexLeanPreservation.Obs := theorem root (base : Nat) (offset : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat base), (_root_.LexLeanTarget.TargetSyntax.Value.nat offset)] (_root_.LexLeanPreservation.Rel (__fits_0 base offset) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Main.higher base offset))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 base offset) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustCore.lex.tex index 904847861..282990829 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.root : @914 := @915 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -82,7 +82,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -193,12 +193,12 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.__fits_0 @326 := @324 @4 @15 @330 := @5 (Coverage.Main.higher @4 @15) -@333 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.root @4 @15 +@333 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.root @4 @15 @334 := Bool @335 := Ne.{1} @336 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustStd.lex.tex index 9f2580920..563de15db 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.root : @914 := @915 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -82,7 +82,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -193,12 +193,12 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.__fits_0 @326 := @324 @4 @15 @330 := @5 (Coverage.Main.higher @4 @15) -@333 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.root @4 @15 +@333 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.root @4 @15 @334 := Bool @335 := Ne.{1} @336 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustCore.lean index faa15cb6b..fafff49bc 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -64,4 +64,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustStd.lean index cddecbc09..838afc3ef 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -64,4 +64,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19.lean index c7a392bbc..d6a1fa9da 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -78,4 +78,4 @@ def denote (values : (List Nat)) : _root_.LexLeanPreservation.Obs := theorem root (values : (List Nat)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] (_root_.LexLeanPreservation.Rel (__fits_0 values) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bool) (Coverage.Main.mapped values))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 values) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/Compose/RustStd.lex.tex index 30f54881c..1e8ad431b 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.root : @926 := @927 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.root : @926 := @927 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -124,7 +124,7 @@ @195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 @200 := List.getD.{0} @181 @183 @170 @195 @204 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.root @15 @170 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.root @15 @170 @205 := LexLeanPreservation.Rust.WTL @213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 @215 := LexLeanPreservation.Rust.wtl_nil @0 @@ -202,15 +202,15 @@ @366 := @360 @229 @367 := @230 @166 @368 := @367 @356 -@369 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.denote +@369 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.denote @370 := @369 @6 -@371 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.__fits_0 +@371 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.__fits_0 @372 := @371 @6 @374 := Coverage.Main.mapped @6 @375 := Bool @376 := LexLeanTarget.TargetSyntax.Value.bool @379 := @8 @375 @376 @374 -@381 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.root @6 +@381 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.root @6 @382 := Ne.{1} @383 := LexLeanPreservation.Obs @384 := @382 @383 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/RustStd.lean index 098c420b2..2f5fa243f 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -56,4 +56,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2.lean similarity index 87% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2.lean index d1f256be5..ce01e3fb5 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -85,26 +85,26 @@ def entryValue (m : (List (Prod Nat Nat))) (bonus : Nat) : _root_.LexLeanTarget. /-- The entry's observation. -/ def denoteEntry (m : (List (Prod Nat Nat))) (bonus : Nat) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryFits m bonus) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryValue m bonus)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryFits m bonus) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryValue m bonus)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (m : (List (Prod Nat Nat))) (bonus : Nat) : Prop := (__inv_3 m ∧ _root_.True) -theorem entry (m : (List (Prod Nat Nat))) (bonus : Nat) : _root_.LexLeanPreservation.RunConv __prog 5 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.nat bonus)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry m bonus) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 m bonus else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Colls.mapFolding m bonus))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_3 m) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_3 m)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 m bonus)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryFits])) +theorem entry (m : (List (Prod Nat Nat))) (bonus : Nat) : _root_.LexLeanPreservation.RunConv __prog 5 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.nat bonus)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry m bonus) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 m bonus else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.Colls.mapFolding m bonus))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_3 m) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_3 m)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 m bonus)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryFits])) -theorem entry_accepts (m : (List (Prod Nat Nat))) (bonus : Nat) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.accepts m bonus) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry m bonus = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denote m bonus) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denote +theorem entry_accepts (m : (List (Prod Nat Nat))) (bonus : Nat) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.accepts m bonus) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry m bonus = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denote m bonus) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denote simp only [_root_.if_true, (__viff_3 m).mpr __h.1] cases __fits_0 m bonus <;> rfl -theorem entry_refuses (m : (List (Prod Nat Nat))) (bonus : Nat) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.accepts m bonus) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry m bonus = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryValue +theorem entry_refuses (m : (List (Prod Nat Nat))) (bonus : Nat) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.accepts m bonus) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry m bonus = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryValue cases __c0 : __valid_3 m · simp · exact _root_.absurd ⟨(__viff_3 m).mp __c0, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/Compose/RustStd.lex.tex index 42e6f3b8d..281b92c11 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.root : @1352 := @1353 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.root : @1352 := @1353 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.flags @3 := Nat @4 := Prod.{0, 0} @5 := @4 @3 @@ -220,7 +220,7 @@ @393 := LexLeanTarget.TargetSyntax.Function.mk @382 @383 @384 @388 @398 := List.getD.{0} @378 @380 @381 @393 @402 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.root @26 @381 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.root @26 @381 @403 := LexLeanPreservation.Rust.WTL @411 := {p : @27} -> {c : @28} -> {A : @29} -> @403 @9 @34 @26 @355 @383 @413 := LexLeanPreservation.Rust.wtl_nil @0 @@ -329,12 +329,12 @@ @621 := @615 @563 @622 := @428 @360 @623 := @622 @611 -@624 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denoteEntry +@624 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denoteEntry @626 := @624 @9 @34 -@627 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryFits +@627 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryFits @629 := @627 @9 @34 -@632 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entryValue @9 @34 -@635 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entry @9 @34 +@632 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entryValue @9 @34 +@635 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entry @9 @34 @636 := Bool @637 := Ne.{1} @638 := LexLeanPreservation.Obs @@ -592,10 +592,10 @@ @1210 := @858 @617 @26 @1211 := @1208 @1210 @1213 := @727 (fun (ro : @726) => @1211) -@1214 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.accepts +@1214 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.accepts @1216 := @1214 @9 @34 @1217 := LexLeanPreservation.someObs -@1218 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.denote +@1218 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.denote @1221 := @1217 (@1218 @9 @34) @1224 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1225 := Not @@ -621,13 +621,13 @@ @1262 := Eq.subst.{1} @1264 := @1214 @78 @31 @1265 := @1225 @1264 -@1269 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entry_accepts @71 @78 @26 +@1269 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entry_accepts @71 @78 @26 @1272 := @1217 (@1218 @71 @78) @1277 := @1251 (@1183 @9) (@1186 @9) @34 @1279 := fun (__e_o : @638) => @1259 @31 @1282 := @1262 @638 @1279 @1115 @1286 := fun (__e_h : @1264) => @1282 @1272 @1269 @1277 -@1290 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.entry_refuses @71 @78 @26 +@1290 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.entry_refuses @71 @78 @26 @1294 := fun (__e_h : @1265) => @1282 @1224 @1290 @1277 @1295 := And.intro @1298 := @1264 -> @1001 @1272 @9 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/RustStd.lean index 9de8fee65..6e64da704 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -72,4 +72,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20.lean index b40d3403c..894aa23a6 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -68,4 +68,4 @@ def denote (n : Nat) : _root_.LexLeanPreservation.Obs := theorem root (n : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] (_root_.LexLeanPreservation.Rel (__fits_0 n) (_root_.LexLeanTarget.TargetSyntax.Value.bool (Coverage.Main.parity n))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 n) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustCore.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustCore.lex.tex index 4a4fb8539..efc9db741 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.root : @826 := @827 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.root : @826 := @827 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.root @17 @60 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,13 +158,13 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.denote +@271 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.__fits_0 +@273 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.__fits_0 @274 := @273 @4 @276 := Coverage.Main.parity @4 @278 := LexLeanTarget.TargetSyntax.Value.bool @276 -@280 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.root @4 +@280 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.root @4 @281 := Bool @282 := Ne.{1} @283 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustStd.lex.tex index 383d6f1f0..904320d7e 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.root : @826 := @827 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.root : @826 := @827 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.root @17 @60 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,13 +158,13 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.denote +@271 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.__fits_0 +@273 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.__fits_0 @274 := @273 @4 @276 := Coverage.Main.parity @4 @278 := LexLeanTarget.TargetSyntax.Value.bool @276 -@280 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.root @4 +@280 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.root @4 @281 := Bool @282 := Ne.{1} @283 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustCore.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustCore.lean index 7991e1599..68a4a0a91 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -46,4 +46,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustStd.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustStd.lean index 799c91a37..7e964dc48 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -46,4 +46,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21.lean index 6394deea1..6417f2565 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int8) (b : Int8) : _root_.LexLeanPreservation.Obs := theorem root (a : Int8) (b : Int8) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.i8 a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i8) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i8) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i8) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i8) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i8))))) (Coverage.Prims.fixedSmall a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustCore.lex.tex index 65332170c..5d8950db4 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.root : @939 := @940 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.root : @939 := @940 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.flags @3 := Int8 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.i8 @@ -84,7 +84,7 @@ @100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 @105 := List.getD.{0} @85 @87 @75 @100 @109 := fun (__e_n : @65) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.root @19 @75 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.root @19 @75 @110 := LexLeanPreservation.Rust.WTL @118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 @120 := LexLeanPreservation.Rust.wtl_nil @0 @@ -195,9 +195,9 @@ @321 := @316 @278 @322 := @135 @64 @323 := @322 @312 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.denote +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.denote @326 := @324 @4 @17 -@327 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.__fits_0 +@327 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.__fits_0 @329 := @327 @4 @17 @332 := Coverage.Prims.fixedSmall @4 @17 @333 := Option.{0} @@ -212,7 +212,7 @@ @349 := @343 @336 @341 @346 @352 := @343 @337 @341 @349 @356 := @343 @338 @341 @352 @332 -@359 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.root @4 @17 +@359 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.root @4 @17 @360 := Bool @361 := Ne.{1} @362 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustStd.lex.tex index 9f91173d2..6642e639a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.root : @939 := @940 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.root : @939 := @940 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.flags @3 := Int8 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.i8 @@ -84,7 +84,7 @@ @100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 @105 := List.getD.{0} @85 @87 @75 @100 @109 := fun (__e_n : @65) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.root @19 @75 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.root @19 @75 @110 := LexLeanPreservation.Rust.WTL @118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 @120 := LexLeanPreservation.Rust.wtl_nil @0 @@ -195,9 +195,9 @@ @321 := @316 @278 @322 := @135 @64 @323 := @322 @312 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.denote +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.denote @326 := @324 @4 @17 -@327 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.__fits_0 +@327 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.__fits_0 @329 := @327 @4 @17 @332 := Coverage.Prims.fixedSmall @4 @17 @333 := Option.{0} @@ -212,7 +212,7 @@ @349 := @343 @336 @341 @346 @352 := @343 @337 @341 @349 @356 := @343 @338 @341 @352 @332 -@359 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.root @4 @17 +@359 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.root @4 @17 @360 := Bool @361 := Ne.{1} @362 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustCore.lean index 8903a4973..cd3b8990b 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustStd.lean index 36609186f..b22784e9d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22.lean index 8fe02a672..c438832e9 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int16) (b : Int32) : _root_.LexLeanPreservation.Obs := theorem root (a : Int16) (b : Int32) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.i16 a), (_root_.LexLeanTarget.TargetSyntax.Value.i32 b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i16) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i32) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i32) _root_.LexLeanTarget.TargetSyntax.Value.bool))) (Coverage.Prims.fixedMiddle a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustCore.lex.tex index 30ad892e6..a45361f75 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.root : @1000 := @1001 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.root : @1000 := @1001 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.flags @3 := Int16 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.i16 @@ -96,7 +96,7 @@ @127 := LexLeanTarget.TargetSyntax.Function.mk @116 @117 @118 @122 @132 := List.getD.{0} @112 @114 @102 @127 @136 := fun (__e_n : @92) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.root @19 @102 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.root @19 @102 @137 := LexLeanPreservation.Rust.WTL @145 := {p : @10} -> {c : @11} -> {A : @12} -> @137 @4 @17 @19 @86 @117 @147 := LexLeanPreservation.Rust.wtl_nil @0 @@ -217,9 +217,9 @@ @367 := @361 @309 @368 := @162 @91 @369 := @368 @357 -@370 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.denote +@370 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.denote @372 := @370 @4 @17 -@373 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.__fits_0 +@373 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.__fits_0 @375 := @373 @4 @17 @378 := Coverage.Prims.fixedMiddle @4 @17 @379 := Option.{0} @@ -238,7 +238,7 @@ @396 := @393 @382 @390 @391 @399 := @393 @384 @390 @396 @404 := @392 @380 @385 @388 @399 @378 -@407 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.root @4 @17 +@407 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.root @4 @17 @408 := Ne.{1} @409 := LexLeanPreservation.Obs @410 := @408 @409 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustStd.lex.tex index 27f070392..b1923e053 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.root : @1000 := @1001 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.root : @1000 := @1001 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.flags @3 := Int16 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.i16 @@ -96,7 +96,7 @@ @127 := LexLeanTarget.TargetSyntax.Function.mk @116 @117 @118 @122 @132 := List.getD.{0} @112 @114 @102 @127 @136 := fun (__e_n : @92) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.root @19 @102 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.root @19 @102 @137 := LexLeanPreservation.Rust.WTL @145 := {p : @10} -> {c : @11} -> {A : @12} -> @137 @4 @17 @19 @86 @117 @147 := LexLeanPreservation.Rust.wtl_nil @0 @@ -217,9 +217,9 @@ @367 := @361 @309 @368 := @162 @91 @369 := @368 @357 -@370 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.denote +@370 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.denote @372 := @370 @4 @17 -@373 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.__fits_0 +@373 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.__fits_0 @375 := @373 @4 @17 @378 := Coverage.Prims.fixedMiddle @4 @17 @379 := Option.{0} @@ -238,7 +238,7 @@ @396 := @393 @382 @390 @391 @399 := @393 @384 @390 @396 @404 := @392 @380 @385 @388 @399 @378 -@407 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.root @4 @17 +@407 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.root @4 @17 @408 := Ne.{1} @409 := LexLeanPreservation.Obs @410 := @408 @409 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustCore.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustCore.lean index a50182eb9..fb2f8ebb1 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustStd.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustStd.lean index 3c32afc98..32392da23 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23.lean index ea8a95fb4..8c8731752 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int64) (b : Int64) (c : UInt64) : _root_.LexLeanPreservation.Obs theorem root (a : Int64) (b : Int64) (c : UInt64) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.i64 a), (_root_.LexLeanTarget.TargetSyntax.Value.i64 b), (_root_.LexLeanTarget.TargetSyntax.Value.u64 c)] (_root_.LexLeanPreservation.Rel (__fits_0 a b c) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u64)))))) (Coverage.Prims.fixedWide a b c))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b c) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustCore.lex.tex index 01829914d..fdfcf9871 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.root : @1096 := @1097 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.root : @1096 := @1097 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.flags @3 := Int64 @4 := #3 @5 := LexLeanTarget.TargetSyntax.Value.i64 @@ -106,7 +106,7 @@ @138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 @143 := List.getD.{0} @123 @125 @111 @138 @147 := fun (__e_n : @98) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.root @19 @111 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.root @19 @111 @148 := LexLeanPreservation.Rust.WTL @156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 @158 := LexLeanPreservation.Rust.wtl_nil @0 @@ -249,9 +249,9 @@ @417 := @412 @374 @418 := @173 @97 @419 := @418 @408 -@420 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.denote +@420 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.denote @423 := @420 @4 @15 @17 -@424 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.__fits_0 +@424 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.__fits_0 @427 := @424 @4 @15 @17 @431 := Coverage.Prims.fixedWide @4 @15 @17 @432 := Option.{0} @@ -271,7 +271,7 @@ @455 := @446 @437 @442 @452 @458 := @446 @438 @442 @455 @462 := @446 @439 @442 @458 @431 -@466 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.root @4 @15 @17 +@466 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.root @4 @15 @17 @467 := Bool @468 := Ne.{1} @469 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustStd.lex.tex index f3f183f6e..117f11405 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.root : @1096 := @1097 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.root : @1096 := @1097 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.flags @3 := Int64 @4 := #3 @5 := LexLeanTarget.TargetSyntax.Value.i64 @@ -106,7 +106,7 @@ @138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 @143 := List.getD.{0} @123 @125 @111 @138 @147 := fun (__e_n : @98) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.root @19 @111 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.root @19 @111 @148 := LexLeanPreservation.Rust.WTL @156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 @158 := LexLeanPreservation.Rust.wtl_nil @0 @@ -249,9 +249,9 @@ @417 := @412 @374 @418 := @173 @97 @419 := @418 @408 -@420 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.denote +@420 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.denote @423 := @420 @4 @15 @17 -@424 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.__fits_0 +@424 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.__fits_0 @427 := @424 @4 @15 @17 @431 := Coverage.Prims.fixedWide @4 @15 @17 @432 := Option.{0} @@ -271,7 +271,7 @@ @455 := @446 @437 @442 @452 @458 := @446 @438 @442 @455 @462 := @446 @439 @442 @458 @431 -@466 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.root @4 @15 @17 +@466 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.root @4 @15 @17 @467 := Bool @468 := Ne.{1} @469 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustCore.lean index d202b11b6..53bed3572 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustStd.lean index 91a310f6d..44ff72155 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24.lean index 95af6ef07..50d60c0ad 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : UInt16) (b : UInt16) (s : UInt32) : _root_.LexLeanPreservation.O theorem root (a : UInt16) (b : UInt16) (s : UInt32) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.u16 a), (_root_.LexLeanTarget.TargetSyntax.Value.u16 b), (_root_.LexLeanTarget.TargetSyntax.Value.u32 s)] (_root_.LexLeanPreservation.Rel (__fits_0 a b s) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u16 (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u16 (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u16 (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u16 (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u16) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u16) _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Prims.bits a b s))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b s) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustCore.lex.tex index fa89a1a3a..cb785a896 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.root : @1100 := @1101 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.root : @1100 := @1101 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.flags @3 := UInt16 @4 := #3 @5 := LexLeanTarget.TargetSyntax.Value.u16 @@ -106,7 +106,7 @@ @138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 @143 := List.getD.{0} @123 @125 @111 @138 @147 := fun (__e_n : @98) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.root @19 @111 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.root @19 @111 @148 := LexLeanPreservation.Rust.WTL @156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 @158 := LexLeanPreservation.Rust.wtl_nil @0 @@ -249,9 +249,9 @@ @417 := @412 @374 @418 := @173 @97 @419 := @418 @408 -@420 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.denote +@420 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.denote @423 := @420 @4 @15 @17 -@424 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.__fits_0 +@424 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.__fits_0 @427 := @424 @4 @15 @17 @431 := Coverage.Prims.bits @4 @15 @17 @432 := Option.{0} @@ -275,7 +275,7 @@ @460 := @454 @439 @5 @457 @463 := @454 @440 @5 @460 @467 := @454 @441 @5 @463 @431 -@471 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.root @4 @15 @17 +@471 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.root @4 @15 @17 @472 := Ne.{1} @473 := LexLeanPreservation.Obs @474 := @472 @473 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustStd.lex.tex index 1b7912607..0b5be3aa5 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.root : @1100 := @1101 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.root : @1100 := @1101 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.flags @3 := UInt16 @4 := #3 @5 := LexLeanTarget.TargetSyntax.Value.u16 @@ -106,7 +106,7 @@ @138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 @143 := List.getD.{0} @123 @125 @111 @138 @147 := fun (__e_n : @98) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.root @19 @111 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.root @19 @111 @148 := LexLeanPreservation.Rust.WTL @156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 @158 := LexLeanPreservation.Rust.wtl_nil @0 @@ -249,9 +249,9 @@ @417 := @412 @374 @418 := @173 @97 @419 := @418 @408 -@420 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.denote +@420 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.denote @423 := @420 @4 @15 @17 -@424 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.__fits_0 +@424 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.__fits_0 @427 := @424 @4 @15 @17 @431 := Coverage.Prims.bits @4 @15 @17 @432 := Option.{0} @@ -275,7 +275,7 @@ @460 := @454 @439 @5 @457 @463 := @454 @440 @5 @460 @467 := @454 @441 @5 @463 @431 -@471 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.root @4 @15 @17 +@471 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.root @4 @15 @17 @472 := Ne.{1} @473 := LexLeanPreservation.Obs @474 := @472 @473 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustCore.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustCore.lean index 13c621a46..bf2d877e3 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustStd.lean index b9d86a570..13b6f9d9f 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25.lean index 05da2f869..4fc7ecab0 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int) (b : Int8) : _root_.LexLeanPreservation.Obs := theorem root (a : Int) (b : Int8) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u16) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.i64)) (Coverage.Prims.conversions a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustCore.lex.tex index 4f31cdb2b..a2efadcde 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.root : @992 := @993 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.root : @992 := @993 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.flags @3 := Int @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.int @@ -94,7 +94,7 @@ @126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 @131 := List.getD.{0} @111 @113 @101 @126 @135 := fun (__e_n : @91) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.root @17 @101 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.root @17 @101 @136 := LexLeanPreservation.Rust.WTL @144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 @146 := LexLeanPreservation.Rust.wtl_nil @0 @@ -215,9 +215,9 @@ @366 := @360 @308 @367 := @161 @90 @368 := @367 @356 -@369 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.denote +@369 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.denote @371 := @369 @4 @15 -@372 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.__fits_0 +@372 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.__fits_0 @374 := @372 @4 @15 @377 := Coverage.Prims.conversions @4 @15 @378 := UInt16 @@ -231,7 +231,7 @@ @387 := LexLeanTarget.TargetSyntax.Value.i64 @389 := @384 @381 @387 @395 := LexLeanPreservation.encPair @380 @382 @386 @389 @377 -@398 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.root @4 @15 +@398 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.root @4 @15 @399 := Bool @400 := Ne.{1} @401 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustStd.lex.tex index 97b21c89b..be2566fab 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.root : @992 := @993 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.root : @992 := @993 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.flags @3 := Int @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.int @@ -94,7 +94,7 @@ @126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 @131 := List.getD.{0} @111 @113 @101 @126 @135 := fun (__e_n : @91) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.root @17 @101 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.root @17 @101 @136 := LexLeanPreservation.Rust.WTL @144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 @146 := LexLeanPreservation.Rust.wtl_nil @0 @@ -215,9 +215,9 @@ @366 := @360 @308 @367 := @161 @90 @368 := @367 @356 -@369 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.denote +@369 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.denote @371 := @369 @4 @15 -@372 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.__fits_0 +@372 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.__fits_0 @374 := @372 @4 @15 @377 := Coverage.Prims.conversions @4 @15 @378 := UInt16 @@ -231,7 +231,7 @@ @387 := LexLeanTarget.TargetSyntax.Value.i64 @389 := @384 @381 @387 @395 := LexLeanPreservation.encPair @380 @382 @386 @389 @377 -@398 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.root @4 @15 +@398 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.root @4 @15 @399 := Bool @400 := Ne.{1} @401 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustCore.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustCore.lean index e4661d900..707d864ca 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustStd.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustStd.lean index e61055a18..d64f05416 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26.lean index 77f1674c6..ad6e78f98 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (xs : (List Nat)) (b : ByteArray) (i : Nat) : _root_.LexLeanPreservat theorem root (xs : (List Nat)) (b : ByteArray) (i : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), (_root_.LexLeanTarget.TargetSyntax.Value.bytes b), (_root_.LexLeanTarget.TargetSyntax.Value.nat i)] (_root_.LexLeanPreservation.Rel (__fits_0 xs b i) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bytes (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.bool)))))))) (Coverage.Prims.sequences xs b i))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 xs b i) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/Compose/RustStd.lex.tex similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/Compose/RustStd.lex.tex index f3e7d03f7..f9f82b21b 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.root : @1256 := @1257 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -155,7 +155,7 @@ @243 := LexLeanTarget.TargetSyntax.Function.mk @232 @233 @234 @238 @248 := List.getD.{0} @229 @231 @217 @243 @252 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.root @15 @217 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.root @15 @217 @253 := LexLeanPreservation.Rust.WTL @261 := {p : @16} -> {c : @17} -> {A : @18} -> @253 @21 @23 @15 @197 @233 @263 := LexLeanPreservation.Rust.wtl_nil @0 @@ -297,9 +297,9 @@ @530 := @524 @472 @531 := @278 @204 @532 := @531 @520 -@533 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.denote +@533 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.denote @536 := @533 @6 @21 @23 -@537 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.__fits_0 +@537 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.__fits_0 @540 := @537 @6 @21 @23 @544 := Coverage.Prims.sequences @6 @21 @23 @545 := Option.{0} @@ -332,7 +332,7 @@ @600 := @576 @3 @561 @7 @596 @604 := @576 @161 @562 @162 @600 @609 := @576 @5 @564 @10 @604 @544 -@613 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.root @6 @21 @23 +@613 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.root @6 @21 @23 @614 := Ne.{1} @615 := LexLeanPreservation.Obs @616 := @614 @615 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/RustStd.lean index bc8e07265..7950a9d9d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27.lean index 18cdb9563..725843a12 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (s : String) : _root_.LexLeanPreservation.Obs := theorem root (s : String) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.string s)] (_root_.LexLeanPreservation.Rel (__fits_0 s) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.int) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u32)) (Coverage.Prims.decimals s))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 s) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/Compose/RustStd.lex.tex index 9560cadd0..797f73dc7 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.root : @842 := @843 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.root : @842 := @843 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.flags @3 := String @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.string @@ -72,7 +72,7 @@ @87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 @92 := List.getD.{0} @72 @74 @61 @87 @96 := fun (__e_n : @57) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.root @17 @61 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.root @17 @61 @97 := LexLeanPreservation.Rust.WTL @105 := {p : @8} -> {c : @9} -> {A : @10} -> @97 @14 @4 @17 @53 @77 @107 := LexLeanPreservation.Rust.wtl_nil @0 @@ -159,9 +159,9 @@ @269 := @263 @121 @270 := @122 @56 @271 := @270 @259 -@272 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.denote +@272 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.denote @273 := @272 @4 -@274 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.__fits_0 +@274 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.__fits_0 @275 := @274 @4 @277 := Coverage.Prims.decimals @4 @278 := Int @@ -175,7 +175,7 @@ @287 := LexLeanTarget.TargetSyntax.Value.u32 @289 := @284 @281 @287 @295 := LexLeanPreservation.encPair @280 @282 @286 @289 @277 -@297 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.root @4 +@297 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.root @4 @298 := Bool @299 := Ne.{1} @300 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/RustStd.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/RustStd.lean index e61101eab..33ead28d2 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28.lean index abb8651df..288a8dd1c 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (a : Int) (b : Int8) : _root_.LexLeanPreservation.Obs := theorem root (a : Int) (b : Int8) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.string) (Coverage.Prims.formats a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/Compose/RustStd.lex.tex index 47bda3ae9..80f4dc203 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.root : @983 := @984 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.root : @983 := @984 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.flags @3 := Int @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.int @@ -94,7 +94,7 @@ @126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 @131 := List.getD.{0} @111 @113 @101 @126 @135 := fun (__e_n : @91) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.root @17 @101 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.root @17 @101 @136 := LexLeanPreservation.Rust.WTL @144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 @146 := LexLeanPreservation.Rust.wtl_nil @0 @@ -215,15 +215,15 @@ @366 := @360 @308 @367 := @161 @90 @368 := @367 @356 -@369 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.denote +@369 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.denote @371 := @369 @4 @15 -@372 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.__fits_0 +@372 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.__fits_0 @374 := @372 @4 @15 @377 := Coverage.Prims.formats @4 @15 @378 := String @379 := LexLeanTarget.TargetSyntax.Value.string @385 := LexLeanPreservation.encPair @378 @378 @379 @379 @377 -@388 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.root @4 @15 +@388 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.root @4 @15 @389 := Bool @390 := Ne.{1} @391 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/RustStd.lean similarity index 95% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/RustStd.lean index 79cb03aa2..0ad5b17f3 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29.lean index 12e536513..8e0568f7d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (s : String) (d : String) : _root_.LexLeanPreservation.Obs := theorem root (s : String) (d : String) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.string s), (_root_.LexLeanTarget.TargetSyntax.Value.string d)] (_root_.LexLeanPreservation.Rel (__fits_0 s d) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bytes (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.string) (_root_.LexLeanPreservation.encPair _root_.LexLeanPreservation.encOrdering (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string)) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)))))) (Coverage.Prims.text s d))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 s d) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/Compose/RustStd.lex.tex index 8b0f6d13e..29fcd092f 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.root : @966 := @967 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.root : @966 := @967 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.flags @3 := String @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.string @@ -85,7 +85,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.root @17 @73 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -196,9 +196,9 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.denote +@322 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.__fits_0 +@325 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.__fits_0 @327 := @325 @4 @15 @330 := Coverage.Prims.text @4 @15 @331 := ByteArray @@ -228,7 +228,7 @@ @375 := @359 @334 @342 @351 @371 @379 := @359 @333 @344 @350 @375 @384 := @359 @331 @346 @347 @379 @330 -@387 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.root @4 @15 +@387 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.root @4 @15 @388 := Ne.{1} @389 := LexLeanPreservation.Obs @390 := @388 @389 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/RustStd.lean index c10025621..eee33fcd4 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3.lean similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3.lean index 101b6c4e9..9a41658d1 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -79,28 +79,28 @@ def entryValue (s : (List Nat)) (t : (List Nat)) (x : Nat) : _root_.LexLeanTarge /-- The entry's observation. -/ def denoteEntry (s : (List Nat)) (t : (List Nat)) (x : Nat) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryFits s t x) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryValue s t x)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryFits s t x) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryValue s t x)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (s : (List Nat)) (t : (List Nat)) (x : Nat) : Prop := (__inv_10 s ∧ (__inv_10 t ∧ _root_.True)) -theorem entry (s : (List Nat)) (t : (List Nat)) (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 11 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) s), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) t), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry s t x) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_10 t then __fits_0 s t x else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_10 t then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))))))) (Coverage.Colls.setOps s t x))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 s) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 s)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 s t x else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))))))) (Coverage.Colls.setOps s t x))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 t) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 t)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (__rel_0 s t x)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryFits])) +theorem entry (s : (List Nat)) (t : (List Nat)) (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 11 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) s), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) t), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry s t x) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_10 t then __fits_0 s t x else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_10 t then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))))))) (Coverage.Colls.setOps s t x))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 s) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 s)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 s t x else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))))))) (Coverage.Colls.setOps s t x))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 t) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 t)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (__rel_0 s t x)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryFits])) -theorem entry_accepts (s : (List Nat)) (t : (List Nat)) (x : Nat) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.accepts s t x) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry s t x = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denote s t x) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denote +theorem entry_accepts (s : (List Nat)) (t : (List Nat)) (x : Nat) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.accepts s t x) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry s t x = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denote s t x) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denote simp only [_root_.if_true, (__viff_10 s).mpr __h.1, (__viff_10 t).mpr __h.2.1] cases __fits_0 s t x <;> rfl -theorem entry_refuses (s : (List Nat)) (t : (List Nat)) (x : Nat) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.accepts s t x) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry s t x = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryValue +theorem entry_refuses (s : (List Nat)) (t : (List Nat)) (x : Nat) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.accepts s t x) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry s t x = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryValue cases __c0 : __valid_10 s · simp · cases __c1 : __valid_10 t · simp · exact _root_.absurd ⟨(__viff_10 s).mp __c0, (__viff_10 t).mp __c1, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/Compose/RustStd.lex.tex index 2c6e34676..4e3752683 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.root : @1271 := @1272 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.root : @1271 := @1272 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -143,7 +143,7 @@ @218 := LexLeanTarget.TargetSyntax.Function.mk @207 @208 @209 @213 @223 := List.getD.{0} @203 @205 @206 @218 @227 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.root @15 @206 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.root @15 @206 @228 := LexLeanPreservation.Rust.WTL @236 := {p : @16} -> {c : @17} -> {A : @18} -> @228 @21 @23 @15 @171 @208 @238 := LexLeanPreservation.Rust.wtl_nil @0 @@ -277,12 +277,12 @@ @486 := @481 @443 @487 := @253 @178 @488 := @487 @477 -@489 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denoteEntry +@489 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denoteEntry @492 := @489 @6 @21 @23 -@493 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryFits +@493 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryFits @496 := @493 @6 @21 @23 -@500 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entryValue @6 @21 @23 -@504 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entry @6 @21 @23 +@500 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entryValue @6 @21 @23 +@504 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entry @6 @21 @23 @505 := Bool @506 := Ne.{1} @507 := LexLeanPreservation.Obs @@ -549,10 +549,10 @@ @1115 := @731 @482 @15 @1116 := @1113 @1115 @1118 := @600 (fun (ro : @599) => @1116) -@1119 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.accepts +@1119 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.accepts @1122 := @1119 @6 @21 @23 @1123 := LexLeanPreservation.someObs -@1124 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.denote +@1124 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.denote @1128 := @1123 (@1124 @6 @21 @23) @1131 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1132 := Not @@ -578,13 +578,13 @@ @1172 := Eq.subst.{1} @1175 := @1119 @62 @64 @6 @1176 := @1132 @1175 -@1181 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entry_accepts @60 @62 @64 @15 +@1181 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entry_accepts @60 @62 @64 @15 @1185 := @1123 (@1124 @60 @62 @64) @1190 := @1161 (@1088 @21) (@1091 @21) @23 @1192 := fun (__e_o : @507) => @1169 @6 @1195 := @1172 @507 @1192 @1018 @1199 := fun (__e_h : @1175) => @1195 @1185 @1181 @1190 -@1204 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.entry_refuses @60 @62 @64 @15 +@1204 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.entry_refuses @60 @62 @64 @15 @1208 := fun (__e_h : @1176) => @1195 @1131 @1204 @1190 @1209 := And.intro @1212 := @1175 -> @890 @1185 @21 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/RustStd.lean index ff2748970..01c234c12 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -118,4 +118,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30.lean index 7b68b3468..21755242b 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, (.list (.adt 0))]] }], functions := [ @@ -79,4 +79,4 @@ def denote (n : Nat) : _root_.LexLeanPreservation.Obs := theorem root (n : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] (_root_.LexLeanPreservation.Rel (__fits_0 n) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.RecRoots.roseTotal n))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 n) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/Compose/RustStd.lex.tex index 397c9bce7..d781c7f7a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/Compose/RustStd.lex.tex @@ -1,41 +1,41 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wt_0 : @689 := @688 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wt_0 : @689 := @688 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wtItems_0 : @699 := @698 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wtItems_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wtItems_0 : @699 := @698 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wtItems_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.root : @1328 := @1329 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.root : @1328 := @1329 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.flags @3 := Nat @5 := Coverage.Syntax.Rose @3 @6 := #0 -@7 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.__enc_0 +@7 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.__enc_0 @8 := @7 @6 @9 := LexLeanPreservation.Rust.WT @10 := LexLeanTarget.TargetSyntax.Ty.adt @@ -48,7 +48,7 @@ @18 := fun (__v : @5) => @17 @19 := List.{0} @20 := @19 @5 -@21 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.__items_0 +@21 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.__items_0 @22 := @21 @6 @23 := LexLeanPreservation.Rust.WTAll @24 := @23 @0 @@ -77,7 +77,7 @@ @68 := @64 @30 @70 := @15 @33 @34 @71 := LexLeanPreservation.ListEnc.enc -@72 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.__L_0 +@72 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.__L_0 @74 := @71 @5 @72 @75 := @74 @31 @76 := LexLeanTarget.TargetSyntax.Ty.list @@ -359,7 +359,7 @@ @732 := LexLeanTarget.TargetSyntax.Function.mk @722 @166 @723 @727 @737 := List.getD.{0} @719 @721 @11 @732 @741 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.root @6 @11 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.root @6 @11 @742 := @271 @700 @749 := {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @358 @30) -> (hs : @275) -> @363 @221 @750 := @742 @34 @@ -380,12 +380,12 @@ @777 := @772 @196 @778 := @197 @705 @779 := @778 @768 -@780 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.denote +@780 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.denote @781 := @780 @31 -@782 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.__fits_0 +@782 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.__fits_0 @783 := @782 @31 @786 := @32 (Coverage.RecRoots.roseTotal @31) -@788 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.root @31 +@788 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.root @31 @789 := Bool @790 := Ne.{1} @791 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/RustStd.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/RustStd.lean index 59b6fdf61..d47e4e36a 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -47,4 +47,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31.lean index a6afc65d2..16c1f173d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat], [(.adt 0), (.adt 0)], [(.list (.adt 1)), (.adt 0)]] }, @@ -102,4 +102,4 @@ def denote (e : (Coverage.Syntax.Expr)) : _root_.LexLeanPreservation.Obs := theorem root (e : (Coverage.Syntax.Expr)) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 e)] (_root_.LexLeanPreservation.Rel (__fits_0 e) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Coverage.RecRoots.syntaxTotal e))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 e) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/Compose/RustStd.lex.tex index ae503b837..113fc51d8 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/Compose/RustStd.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_0 : @1187 := @1186 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_0 : @1187 := @1186 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_1 : @1201 := @1200 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_1 : @1201 := @1200 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wtItems_0 : @1215 := @1214 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wtItems_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wtItems_0 : @1215 := @1214 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wtItems_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.root : @1800 := @1801 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.root : @1800 := @1801 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.flags @3 := Coverage.Syntax.Expr @4 := #0 -@5 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.__enc_0 +@5 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -53,7 +53,7 @@ @15 := @13 @6 @10 @16 := fun (__v : @3) => @15 @17 := Coverage.Syntax.Stmt -@18 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.__enc_1 +@18 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.__enc_1 @19 := @18 @4 @20 := 1 @21 := @8 @20 @@ -61,7 +61,7 @@ @24 := fun (__v : @17) => @23 @25 := List.{0} @26 := @25 @17 -@27 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.__items_0 +@27 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.__items_0 @28 := @27 @4 @29 := LexLeanPreservation.Rust.WTAll @30 := @29 @0 @@ -318,7 +318,7 @@ @526 := @13 @524 @10 @530 := fun (__x0 : @3) => fun (__x1 : @3) => fun (__ih0 : @526) => fun (__ih1 : @526) => @520 @531 := LexLeanPreservation.ListEnc.enc -@532 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.__L_0 +@532 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.__L_0 @534 := @531 @17 @532 @535 := @534 @43 @536 := LexLeanTarget.TargetSyntax.Ty.list @@ -602,7 +602,7 @@ @1214 := fun (__v : @26) => Coverage.Syntax.Expr.rec_1.{0} @16 @24 @35 @379 @530 @719 @888 @1036 @1065 @1173 @4 @1215 := (__v : @26) -> @34 -@1217 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_0 @47 +@1217 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_0 @47 @1220 := Prod.{0, 0} @42 @75 @1224 := Prod.mk.{0, 0} @42 @75 @9 @1225 := @1224 @524 @@ -620,14 +620,14 @@ @1244 := LexLeanTarget.TargetSyntax.Function.mk @1234 @83 @1235 @1239 @1249 := List.getD.{0} @1231 @1233 @9 @1244 @1253 := fun (__e_n : @42) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.root @4 @9 @1255 := @777 @1217 @111 -@1256 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.denote +@1256 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.denote @1257 := @1256 @47 -@1258 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.__fits_0 +@1258 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.__fits_0 @1259 := @1258 @47 @1262 := @36 (Coverage.RecRoots.syntaxTotal @47) -@1264 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.root @47 +@1264 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.root @47 @1265 := Bool @1266 := Ne.{1} @1267 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/RustStd.lean index f77c4e7db..80845781c 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -57,4 +57,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32.lean index 428f38e9a..b2941f422 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -77,4 +77,4 @@ def denote (a : Nat) (b : Nat) : _root_.LexLeanPreservation.Obs := theorem root (a : Nat) (b : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] (_root_.LexLeanPreservation.Rel (__fits_0 a b) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) (Coverage.RecRoots.wellFounded a b))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 a b) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustCore.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustCore.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustCore.lex.tex index 2fc9dfdb7..b70e487e3 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustCore.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.root : @923 := @924 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.root : @923 := @924 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -83,7 +83,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,16 +194,16 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.__fits_0 @326 := @324 @4 @15 @329 := Coverage.RecRoots.wellFounded @4 @15 @330 := @64 @3 @332 := LexLeanPreservation.encPair @3 @335 := @332 @3 @5 @5 @339 := @332 @330 @5 @335 @329 -@342 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.root @4 @15 +@342 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.root @4 @15 @343 := Bool @344 := Ne.{1} @345 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustStd.lex.tex index 3b69fc866..10470679d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.root : @923 := @924 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -83,7 +83,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,16 +194,16 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.__fits_0 @326 := @324 @4 @15 @329 := Coverage.RecRoots.wellFounded @4 @15 @330 := @64 @3 @332 := LexLeanPreservation.encPair @3 @335 := @332 @3 @5 @5 @339 := @332 @330 @5 @335 @329 -@342 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.root @4 @15 +@342 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.root @4 @15 @343 := Bool @344 := Ne.{1} @345 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustCore.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustCore.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustCore.lean index bc01c810f..9eaac2fa0 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustCore.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -54,4 +54,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustStd.lean index 4742a0cbd..91116b242 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -54,4 +54,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33.lean index 7f478474b..30404793d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat], [(.adt 0), (.adt 0)]] }], functions := [ @@ -68,4 +68,4 @@ def denote (t : (Coverage.Syntax.Term)) : _root_.LexLeanPreservation.Obs := theorem root (t : (Coverage.Syntax.Term)) : _root_.LexLeanPreservation.RunConv __prog 0 [(__enc_0 t)] (_root_.LexLeanPreservation.Rel (__fits_0 t) ((_root_.LexLeanPreservation.encPair __enc_0 __enc_0) (Coverage.RecRoots.rewrite t))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 t) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/Compose/RustStd.lex.tex index ec4eac7ca..eb5995255 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.__wt_0 : @520 := @519 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.root : @1138 := @1139 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.root : @1138 := @1139 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.flags @3 := Coverage.Syntax.Term @4 := #0 -@5 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.__enc_0 +@5 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -285,7 +285,7 @@ @513 := fun (__x0 : @3) => fun (__x1 : @3) => fun (__ih0 : @509) => fun (__ih1 : @509) => @503 @519 := fun (__v : @3) => Coverage.Syntax.Term.rec.{0} @16 @361 @513 @4 @520 := (__v : @3) -> @15 -@522 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.__wt_0 @28 +@522 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.__wt_0 @28 @524 := @61 @507 @60 @527 := Prod.{0, 0} @23 @56 @531 := Prod.mk.{0, 0} @23 @56 @9 @@ -304,7 +304,7 @@ @551 := LexLeanTarget.TargetSyntax.Function.mk @541 @64 @542 @546 @556 := List.getD.{0} @538 @540 @9 @551 @560 := fun (__e_n : @23) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.root @4 @9 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.root @4 @9 @561 := @171 @507 @568 := {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @387 @26) -> (hs : @175) -> @392 @121 @569 := @561 @10 @@ -318,13 +318,13 @@ @586 := @584 @92 @587 := @93 @524 @588 := @587 @369 -@589 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.denote +@589 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.denote @590 := @589 @28 -@591 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.__fits_0 +@591 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.__fits_0 @592 := @591 @28 @594 := Coverage.RecRoots.rewrite @28 @600 := LexLeanPreservation.encPair @3 @3 @5 @5 @594 -@602 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.root @28 +@602 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.root @28 @603 := Bool @604 := Ne.{1} @605 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/RustStd.lean index 75df474e9..e2b89c3be 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -47,4 +47,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4.lean similarity index 87% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4.lean index 9e05957f0..9d2089854 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -81,26 +81,26 @@ def entryValue (xs : (List Nat)) (s : (List Int)) : _root_.LexLeanTarget.TargetS /-- The entry's observation. -/ def denoteEntry (xs : (List Nat)) (s : (List Int)) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryFits xs s) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryValue xs s)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryFits xs s) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryValue xs s)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (xs : (List Nat)) (s : (List Int)) : Prop := (__inv_5 s ∧ _root_.True) -theorem entry (xs : (List Nat)) (s : (List Int)) : _root_.LexLeanPreservation.RunConv __prog 6 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.int) s)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry xs s) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 xs s else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.int) (Coverage.Colls.folds xs s))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_5 s) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_5 s)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 xs s)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryFits])) +theorem entry (xs : (List Nat)) (s : (List Int)) : _root_.LexLeanPreservation.RunConv __prog 6 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.int) s)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry xs s) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 xs s else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.int) (Coverage.Colls.folds xs s))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_5 s) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_5 s)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 xs s)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryFits])) -theorem entry_accepts (xs : (List Nat)) (s : (List Int)) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.accepts xs s) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry xs s = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denote xs s) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denote +theorem entry_accepts (xs : (List Nat)) (s : (List Int)) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.accepts xs s) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry xs s = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denote xs s) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denote simp only [_root_.if_true, (__viff_5 s).mpr __h.1] cases __fits_0 xs s <;> rfl -theorem entry_refuses (xs : (List Nat)) (s : (List Int)) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.accepts xs s) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry xs s = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryValue +theorem entry_refuses (xs : (List Nat)) (s : (List Int)) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.accepts xs s) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry xs s = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryValue cases __c0 : __valid_5 s · simp · exact _root_.absurd ⟨(__viff_5 s).mp __c0, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/Compose/RustStd.lex.tex similarity index 93% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/Compose/RustStd.lex.tex index 682629efa..5fc09dade 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.root : @1228 := @1229 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.root : @1228 := @1229 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -162,7 +162,7 @@ @265 := LexLeanTarget.TargetSyntax.Function.mk @254 @255 @256 @260 @270 := List.getD.{0} @250 @252 @253 @265 @274 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.root @15 @253 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.root @15 @253 @275 := LexLeanPreservation.Rust.WTL @283 := {p : @16} -> {c : @17} -> {A : @18} -> @275 @6 @23 @15 @225 @255 @285 := LexLeanPreservation.Rust.wtl_nil @0 @@ -272,12 +272,12 @@ @494 := @488 @436 @495 := @300 @230 @496 := @495 @484 -@497 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denoteEntry +@497 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denoteEntry @499 := @497 @6 @23 -@500 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryFits +@500 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryFits @502 := @500 @6 @23 -@505 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entryValue @6 @23 -@508 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entry @6 @23 +@505 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entryValue @6 @23 +@508 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entry @6 @23 @509 := Bool @510 := Ne.{1} @511 := LexLeanPreservation.Obs @@ -540,10 +540,10 @@ @1086 := @734 @490 @15 @1087 := @1084 @1086 @1089 := @603 (fun (ro : @602) => @1087) -@1090 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.accepts +@1090 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.accepts @1092 := @1090 @6 @23 @1093 := LexLeanPreservation.someObs -@1094 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.denote +@1094 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.denote @1097 := @1093 (@1094 @6 @23) @1100 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1101 := Not @@ -569,13 +569,13 @@ @1138 := Eq.subst.{1} @1140 := @1090 @64 @20 @1141 := @1101 @1140 -@1145 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entry_accepts @62 @64 @15 +@1145 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entry_accepts @62 @64 @15 @1148 := @1093 (@1094 @62 @64) @1153 := @1127 (@1059 @6) (@1062 @6) @23 @1155 := fun (__e_o : @511) => @1135 @20 @1158 := @1138 @511 @1155 @991 @1162 := fun (__e_h : @1140) => @1158 @1148 @1145 @1153 -@1166 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.entry_refuses @62 @64 @15 +@1166 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.entry_refuses @62 @64 @15 @1170 := fun (__e_h : @1141) => @1158 @1100 @1166 @1153 @1171 := And.intro @1174 := @1140 -> @877 @1148 @6 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/RustStd.lean index c74b5cdaf..0af63f643 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -82,4 +82,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5.lean index 64eb521c0..1130e0af6 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -57,4 +57,4 @@ def denote (n : Nat) (start : Nat) : _root_.LexLeanPreservation.Obs := theorem root (n : Nat) (start : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat n), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] (_root_.LexLeanPreservation.Rel (__fits_0 n start) ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool)) (Coverage.Colls.iterations n start))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 n start) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/Compose/RustStd.lex.tex index ec1bae8ba..7de395383 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.root : @924 := @925 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.root : @924 := @925 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -83,7 +83,7 @@ @97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 @102 := List.getD.{0} @82 @84 @72 @97 @106 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.root @17 @72 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.root @17 @72 @107 := LexLeanPreservation.Rust.WTL @115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 @117 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,9 +194,9 @@ @318 := @313 @275 @319 := @132 @62 @320 := @319 @309 -@321 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.denote +@321 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.denote @323 := @321 @4 @15 -@324 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.__fits_0 +@324 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.__fits_0 @326 := @324 @4 @15 @329 := Coverage.Colls.iterations @4 @15 @330 := Bool @@ -205,7 +205,7 @@ @334 := LexLeanPreservation.encPair @3 @337 := @334 @330 @5 @332 @341 := @334 @331 @5 @337 @329 -@344 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.root @4 @15 +@344 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.root @4 @15 @345 := Ne.{1} @346 := LexLeanPreservation.Obs @347 := @345 @346 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/RustStd.lean index 83633ae55..4fc4b04f5 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -66,4 +66,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6.lean similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6.lean index ffccc2956..50a1a07e9 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -129,26 +129,26 @@ def entryValue (g : (List (Prod Nat (List Nat)))) (start : Nat) : _root_.LexLean /-- The entry's observation. -/ def denoteEntry (g : (List (Prod Nat (List Nat)))) (start : Nat) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryFits g start) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryValue g start)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryFits g start) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryValue g start)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (g : (List (Prod Nat (List Nat)))) (start : Nat) : Prop := (__inv_28 g ∧ _root_.True) -theorem entry (g : (List (Prod Nat (List Nat)))) (start : Nat) : _root_.LexLeanPreservation.RunConv __prog 30 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))) g), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry g start) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g start else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))) (Coverage.Colls.graphs g start))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_28 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_28 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 g start)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryFits])) +theorem entry (g : (List (Prod Nat (List Nat)))) (start : Nat) : _root_.LexLeanPreservation.RunConv __prog 30 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))) g), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry g start) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g start else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)))) (Coverage.Colls.graphs g start))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_28 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_28 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (__rel_0 g start)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryFits])) -theorem entry_accepts (g : (List (Prod Nat (List Nat)))) (start : Nat) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.accepts g start) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry g start = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denote g start) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denote +theorem entry_accepts (g : (List (Prod Nat (List Nat)))) (start : Nat) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.accepts g start) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry g start = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denote g start) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denote simp only [_root_.if_true, (__viff_28 g).mpr __h.1] cases __fits_0 g start <;> rfl -theorem entry_refuses (g : (List (Prod Nat (List Nat)))) (start : Nat) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.accepts g start) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry g start = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryValue +theorem entry_refuses (g : (List (Prod Nat (List Nat)))) (start : Nat) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.accepts g start) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry g start = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryValue cases __c0 : __valid_28 g · simp · exact _root_.absurd ⟨(__viff_28 g).mp __c0, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/Compose/RustStd.lex.tex index d00c6b267..2513a91a2 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.root : @1387 := @1388 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.root : @1387 := @1388 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -237,7 +237,7 @@ @428 := LexLeanTarget.TargetSyntax.Function.mk @417 @418 @419 @423 @433 := List.getD.{0} @413 @415 @416 @428 @437 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.root @30 @416 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.root @30 @416 @438 := LexLeanPreservation.Rust.WTL @446 := {p : @31} -> {c : @32} -> {A : @33} -> @438 @10 @38 @30 @390 @418 @448 := LexLeanPreservation.Rust.wtl_nil @0 @@ -346,12 +346,12 @@ @656 := @650 @598 @657 := @463 @395 @658 := @657 @646 -@659 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denoteEntry +@659 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denoteEntry @661 := @659 @10 @38 -@662 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryFits +@662 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryFits @664 := @662 @10 @38 -@667 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entryValue @10 @38 -@670 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entry @10 @38 +@667 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entryValue @10 @38 +@670 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entry @10 @38 @671 := Bool @672 := Ne.{1} @673 := LexLeanPreservation.Obs @@ -610,10 +610,10 @@ @1245 := @893 @652 @30 @1246 := @1243 @1245 @1248 := @762 (fun (ro : @761) => @1246) -@1249 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.accepts +@1249 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.accepts @1251 := @1249 @10 @38 @1252 := LexLeanPreservation.someObs -@1253 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.denote +@1253 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.denote @1256 := @1252 (@1253 @10 @38) @1259 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1260 := Not @@ -639,13 +639,13 @@ @1297 := Eq.subst.{1} @1299 := @1249 @79 @35 @1300 := @1260 @1299 -@1304 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entry_accepts @77 @79 @30 +@1304 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entry_accepts @77 @79 @30 @1307 := @1252 (@1253 @77 @79) @1312 := @1286 (@1218 @10) (@1221 @10) @38 @1314 := fun (__e_o : @673) => @1294 @35 @1317 := @1297 @673 @1314 @1150 @1321 := fun (__e_h : @1299) => @1317 @1307 @1304 @1312 -@1325 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.entry_refuses @77 @79 @30 +@1325 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.entry_refuses @77 @79 @30 @1329 := fun (__e_h : @1300) => @1317 @1259 @1325 @1312 @1330 := And.intro @1333 := @1299 -> @1036 @1307 @10 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/RustStd.lean index 83d9060e1..caa56a407 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -270,4 +270,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7.lean similarity index 92% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7.lean index b0dee171b..3971c9ce8 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -99,26 +99,26 @@ def entryValue (g : (List (Prod String (List String)))) : _root_.LexLeanTarget.T /-- The entry's observation. -/ def denoteEntry (g : (List (Prod String (List String)))) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryFits g) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryValue g)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryFits g) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryValue g)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (g : (List (Prod String (List String)))) : Prop := (__inv_13 g ∧ _root_.True) -theorem entry (g : (List (Prod String (List String)))) : _root_.LexLeanPreservation.RunConv __prog 15 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string))) g)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry g) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string)) (Coverage.Colls.stringGraph g))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_13 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_13 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__rel_0 g)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryFits])) +theorem entry (g : (List (Prod String (List String)))) : _root_.LexLeanPreservation.RunConv __prog 15 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string))) g)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry g) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 g else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string)) (Coverage.Colls.stringGraph g))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_13 g) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_13 g)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__rel_0 g)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryFits])) -theorem entry_accepts (g : (List (Prod String (List String)))) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.accepts g) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry g = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denote g) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denote +theorem entry_accepts (g : (List (Prod String (List String)))) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.accepts g) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry g = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denote g) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denote simp only [_root_.if_true, (__viff_13 g).mpr __h.1] cases __fits_0 g <;> rfl -theorem entry_refuses (g : (List (Prod String (List String)))) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.accepts g) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry g = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryValue +theorem entry_refuses (g : (List (Prod String (List String)))) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.accepts g) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry g = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryValue cases __c0 : __valid_13 g · simp · exact _root_.absurd ⟨(__viff_13 g).mp __c0, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/Compose/RustStd.lex.tex index ed9ef404a..cdf5ac4e1 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.root : @1256 := @1257 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.flags @3 := String @4 := List.{0} @5 := @4 @3 @@ -231,7 +231,7 @@ @419 := LexLeanTarget.TargetSyntax.Function.mk @408 @409 @410 @414 @424 := List.getD.{0} @404 @406 @407 @419 @428 := fun (__e_n : @390) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.root @30 @407 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.root @30 @407 @429 := LexLeanPreservation.Rust.WTL @437 := {p : @31} -> {c : @32} -> {A : @33} -> @429 @37 @10 @30 @386 @409 @439 := LexLeanPreservation.Rust.wtl_nil @0 @@ -308,12 +308,12 @@ @589 := @583 @453 @590 := @454 @389 @591 := @590 @579 -@592 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denoteEntry +@592 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denoteEntry @593 := @592 @10 -@594 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryFits +@594 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryFits @595 := @594 @10 -@597 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entryValue @10 -@599 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entry @10 +@597 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entryValue @10 +@599 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entry @10 @600 := Bool @601 := Ne.{1} @602 := LexLeanPreservation.Obs @@ -565,10 +565,10 @@ @1130 := @821 @585 @30 @1131 := @1128 @1130 @1133 := @690 (fun (ro : @689) => @1131) -@1134 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.accepts +@1134 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.accepts @1135 := @1134 @10 @1136 := LexLeanPreservation.someObs -@1137 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.denote +@1137 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.denote @1139 := @1136 (@1137 @10) @1142 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @1143 := Not @@ -594,13 +594,13 @@ @1177 := Eq.subst.{1} @1178 := @1134 @35 @1179 := @1143 @1178 -@1182 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entry_accepts @79 @30 +@1182 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entry_accepts @79 @30 @1184 := @1136 (@1137 @79) @1189 := @1166 (@1103 @37) (@1106 @37) @10 @1191 := fun (__e_o : @602) => @1174 @35 @1194 := @1177 @602 @1191 @1037 @1198 := fun (__e_h : @1178) => @1194 @1184 @1182 @1189 -@1201 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.entry_refuses @79 @30 +@1201 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.entry_refuses @79 @30 @1205 := fun (__e_h : @1179) => @1194 @1142 @1201 @1189 @1206 := And.intro @1209 := @1178 -> @941 @1184 @37 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/RustStd.lean index 31c29f26c..013e78a1f 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -150,4 +150,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8.lean similarity index 96% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8.lean index 584e9979f..e99e8e302 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -155,24 +155,24 @@ def entryValue (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String) /-- The entry's observation. -/ def denoteEntry (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) : _root_.LexLeanPreservation.Obs := - _root_.cond (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryFits a k i j b c d e u w) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryValue a k i j b c d e u w)) _root_.LexLeanPreservation.Obs.overflow + _root_.cond (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryFits a k i j b c d e u w) (_root_.LexLeanPreservation.Obs.value (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryValue a k i j b c d e u w)) _root_.LexLeanPreservation.Obs.overflow /-- §17.12's invariants of the validated parameters. -/ def accepts (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) : Prop := (__inv_6 a ∧ (__inv_8 i ∧ (__inv_10 b ∧ (__inv_11 d ∧ (__inv_12 u ∧ _root_.True))))) -theorem entry (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) : _root_.LexLeanPreservation.RunConv __prog 13 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) _root_.LexLeanTarget.TargetSyntax.Value.bool)) a), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) k), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.i8 _root_.LexLeanTarget.TargetSyntax.Value.nat)) i), (_root_.LexLeanTarget.TargetSyntax.Value.i8 j), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat)) b), (_root_.LexLeanTarget.TargetSyntax.Value.bool c), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.int _root_.LexLeanTarget.TargetSyntax.Value.nat)) d), (_root_.LexLeanTarget.TargetSyntax.Value.int e), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u64 _root_.LexLeanTarget.TargetSyntax.Value.nat)) u), (_root_.LexLeanTarget.TargetSyntax.Value.u64 w)] (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry a k i j b c d e u w) := - _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_8 i then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_8 i then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_6 a) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_6 a)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_8 i) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_8 i)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 b) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 b)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_11 d) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_11 d)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 a k i j b c d e u w else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_12 u) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_12 u)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)))))))))) (__rel_0 a k i j b c d e u w)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryFits])) +theorem entry (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) : _root_.LexLeanPreservation.RunConv __prog 13 [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) _root_.LexLeanTarget.TargetSyntax.Value.bool)) a), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) k), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.i8 _root_.LexLeanTarget.TargetSyntax.Value.nat)) i), (_root_.LexLeanTarget.TargetSyntax.Value.i8 j), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat)) b), (_root_.LexLeanTarget.TargetSyntax.Value.bool c), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.int _root_.LexLeanTarget.TargetSyntax.Value.nat)) d), (_root_.LexLeanTarget.TargetSyntax.Value.int e), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u64 _root_.LexLeanTarget.TargetSyntax.Value.nat)) u), (_root_.LexLeanTarget.TargetSyntax.Value.u64 w)] (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry a k i j b c d e u w) := + _root_.LexLeanPreservation.run_of_funRel (_root_.LexLeanPreservation.FunRel.fits_eq (_root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_8 i then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_8 i then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_6 a) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_6 a)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_10 b then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_8 i) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_8 i)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_11 d then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_11 d then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_10 b) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_10 b)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then (if __valid_12 u then __fits_0 a k i j b c d e u w else Bool.true) else Bool.true) (fun __c => if __c then (if __valid_12 u then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_11 d) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_11 d)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_cond (fun __c => if __c then __fits_0 a k i j b c d e u w else Bool.true) (fun __c => if __c then (_root_.LexLeanTarget.TargetSyntax.Value.some ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bool) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.keyTypes a k i j b c d e u w))) else _root_.LexLeanTarget.TargetSyntax.Value.none) (__valid_12 u) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__vrel_12 u)) (fun _ => _root_.LexLeanPreservation.Conv.fits_eq (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)))))))))) (__rel_0 a k i j b c d e u w)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (by simp)) (fun _ => _root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) (by simp [_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryFits])) -theorem entry_accepts (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) (__h : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.accepts a k i j b c d e u w) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry a k i j b c d e u w = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denote a k i j b c d e u w) := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryValue _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denote +theorem entry_accepts (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) (__h : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.accepts a k i j b c d e u w) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry a k i j b c d e u w = _root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denote a k i j b c d e u w) := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryValue _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denote simp only [_root_.if_true, (__viff_6 a).mpr __h.1, (__viff_8 i).mpr __h.2.1, (__viff_10 b).mpr __h.2.2.1, (__viff_11 d).mpr __h.2.2.2.1, (__viff_12 u).mpr __h.2.2.2.2.1] cases __fits_0 a k i j b c d e u w <;> rfl -theorem entry_refuses (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) (__h : ¬ _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.accepts a k i j b c d e u w) : _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry a k i j b c d e u w = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.accepts at __h - unfold _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryFits _root_.LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryValue +theorem entry_refuses (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) (__h : ¬ _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.accepts a k i j b c d e u w) : _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry a k i j b c d e u w = _root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none := by + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.accepts at __h + unfold _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryFits _root_.LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryValue cases __c0 : __valid_6 a · simp · cases __c1 : __valid_8 i @@ -185,4 +185,4 @@ theorem entry_refuses (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat · simp · exact _root_.absurd ⟨(__viff_6 a).mp __c0, (__viff_8 i).mp __c1, (__viff_10 b).mp __c2, (__viff_11 d).mp __c3, (__viff_12 u).mp __c4, _root_.trivial⟩ __h -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/Compose/RustStd.lex.tex similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/Compose/RustStd.lex.tex index c7697e706..c701a3a23 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.root : @3073 := @3074 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.root : @3073 := @3074 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.flags @3 := Nat @4 := String @5 := Prod.{0, 0} @@ -579,7 +579,7 @@ @1132 := LexLeanTarget.TargetSyntax.Function.mk @1121 @1122 @1123 @1127 @1137 := List.getD.{0} @1117 @1119 @1120 @1132 @1141 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.root @40 @1120 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.root @40 @1120 @1142 := LexLeanPreservation.Rust.WTL @1150 := {p : @41} -> {c : @42} -> {A : @43} -> @1142 @47 @49 @40 @1038 @1122 @1152 := LexLeanPreservation.Rust.wtl_nil @0 @@ -961,11 +961,11 @@ @1828 := @1822 @1769 @1829 := @1167 @1059 @1830 := @1829 @1818 -@1831 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denoteEntry +@1831 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denoteEntry @1841 := @1831 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 -@1842 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryFits +@1842 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryFits @1852 := @1842 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 -@1863 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entryValue +@1863 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entryValue @13 @112 @114 @@ -976,7 +976,7 @@ @45 @47 @49 -@1874 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entry +@1874 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entry @13 @112 @114 @@ -1447,10 +1447,10 @@ @2803 := @2102 @1824 @40 @2804 := @2801 @2803 @2806 := @1972 (fun (ro : @1971) => @2804) -@2807 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.accepts +@2807 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.accepts @2817 := @2807 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 @2818 := LexLeanPreservation.someObs -@2819 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.denote +@2819 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.denote @2830 := @2818 (@2819 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49) @2833 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none @2834 := Not @@ -1476,7 +1476,7 @@ @2895 := Eq.subst.{1} @2905 := @2807 @1599 @132 @13 @112 @114 @116 @130 @111 @118 @45 @2906 := @2834 @2905 -@2918 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entry_accepts +@2918 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entry_accepts @1658 @1599 @132 @@ -1493,7 +1493,7 @@ @2936 := fun (__e_o : @1876) => @2892 @45 @2939 := @2895 @1876 @2936 @2692 @2943 := fun (__e_h : @2905) => @2939 @2929 @2918 @2934 -@2955 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.entry_refuses +@2955 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.entry_refuses @1658 @1599 @132 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/RustStd.lean similarity index 99% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/RustStd.lean index eeea6d86f..dc13375cd 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -134,4 +134,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9.lean similarity index 98% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9.lean index 1cf5edb0c..bb70d2b9d 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9.lean @@ -18,7 +18,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9 +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -37,4 +37,4 @@ def denote (x : Nat) (s : String) : _root_.LexLeanPreservation.Obs := theorem root (x : Nat) (s : String) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat x), (_root_.LexLeanTarget.TargetSyntax.Value.string s)] (_root_.LexLeanPreservation.Rel (__fits_0 x s) ((_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))))) (Coverage.Colls.literals x s))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 x s) -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9 +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9 diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/Compose/RustStd.lex.tex similarity index 94% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/Compose/RustStd.lex.tex rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/Compose/RustStd.lex.tex index b1451c0d5..20f5ed5a5 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/Compose/RustStd.lex.tex +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9, - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9, + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.root : @1005 := @1006 { - all: [LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.root], +theorem LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.root : @1005 := @1006 { + all: [LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.program -@1 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.krate -@2 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.flags +@0 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.program +@1 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.krate +@2 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.flags @3 := Nat @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -95,7 +95,7 @@ @123 := LexLeanTarget.TargetSyntax.Function.mk @112 @113 @114 @118 @128 := List.getD.{0} @108 @110 @98 @123 @132 := fun (__e_n : @3) => - LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.root @17 @98 + LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.root @17 @98 @133 := LexLeanPreservation.Rust.WTL @141 := {p : @8} -> {c : @9} -> {A : @10} -> @133 @4 @15 @17 @83 @113 @143 := LexLeanPreservation.Rust.wtl_nil @0 @@ -216,9 +216,9 @@ @363 := @357 @305 @364 := @158 @88 @365 := @364 @353 -@366 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.denote +@366 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.denote @368 := @366 @4 @15 -@369 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.__fits_0 +@369 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.__fits_0 @371 := @369 @4 @15 @374 := Coverage.Colls.literals @4 @15 @376 := @89 @50 @3 @@ -236,7 +236,7 @@ @398 := @388 @379 @396 @402 := @383 @378 @380 @392 @398 @407 := @383 @377 @382 @390 @402 @374 -@410 := LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.root @4 @15 +@410 := LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.root @4 @15 @411 := Bool @412 := Ne.{1} @413 := LexLeanPreservation.Obs diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/RustStd.lean similarity index 97% rename from examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/RustStd.lean rename to examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/RustStd.lean index b813a7277..faf524ebc 100644 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/RustStd.lean +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd +namespace LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd +end LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/audit.txt b/examples/production-coverage/expected/verify/preserve/audit.txt index 910d7f1c4..dd6bfae21 100644 --- a/examples/production-coverage/expected/verify/preserve/audit.txt +++ b/examples/production-coverage/expected/verify/preserve/audit.txt @@ -7737,356 +7737,356 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/production-coverage/expected/verify/preserve/preservation.json b/examples/production-coverage/expected/verify/preserve/preservation.json index 4b511c6ee..7fc9215e7 100644 --- a/examples/production-coverage/expected/verify/preserve/preservation.json +++ b/examples/production-coverage/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":57998,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":57221,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd","sha256":"ef16c1d158065592484689c0c3b3e3e6bcdfe7be098467540ff53f8985e17c62","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd","sha256":"3ce949931dbd00f34b2e5848650a8589633aee9f7f2dd3711dd9d1b29cd25b7b","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"a5c01190f937b1843e326198d03410932ae2cce953def60d4f8e7ff675b68bdb","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.root"},{"byte_length":29473,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":21729,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd","sha256":"e0003787dd6f204d596c98733874ae98cc5275a1c733b26fe1db010b10f84ee3","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd","sha256":"c2488f89ff0a32f2d8b5c5899b3fdedaceb1de2dd8832b2d6750baf77f126756","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"76bb5f6b6ec0515f68e727233214bf5226081ba35443b66e13b626f62df39986","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.root"},{"byte_length":13128,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":19445,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd","sha256":"4aef7e57452011725303ac0739e3d6756c91fef2006ebb974499efc9bc2fc7e0","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd","sha256":"bc8fcf5d50cd3005c0ecc874e7a577068eead7e045cc139745b4b2c1d34cdf10","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"3dfdd77fb5359ed5aa828ac6df46ebc9f834432d4c969de70d7f7859c971518f","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.root"},{"byte_length":26754,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":18245,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd","sha256":"73f915579f2c9b30bef23ae2bd42b0cc25de6627caf7437ff34669fd762ff5f8","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd","sha256":"b343f3c449369609f336d90edeeb160133270ce46739335c11713fb8c19782cf","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"5adb39f144229148e6c8d2a6da87b054708c11ec4825d1d79c5f40d0392b5992","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.root"},{"byte_length":13311,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":17987,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd","sha256":"a89ac9e2317555897bffa5cdfcc2615b08a07c0990e13e4c11988dc9bb7fffc0","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd","sha256":"7c6d81d5f76ee438d6b3f280f5be80429d2f4e708b1ec881f89fd909099a2234","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"62b63a070cb9461cb969d7e0eae493f24d9ffb360657650d1891b8c4c5810253","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.root"},{"byte_length":9201,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":13364,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd","sha256":"36deae0c0d8563e6b76cab58241b60f618158848ed09720240ab20b7d924c4d0","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd","sha256":"111adb1894fcfe6c1653d38324a3244649f1369af5f7b708b3804c0aebca03ee","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"ce1200e6ec899ba84b4e2b461464e4483e731d6738e8002a69904803a4721eda","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.root"},{"byte_length":30366,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":20096,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd","sha256":"493e4bae60c9d8ab6ff23016d1fd67892f58a557f14c1969c7be82ea5d5a4b19","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd","sha256":"61d434095df56a1df6f7937d7faa558cb634d2c5a083d2ab9a8c31859cb20c5e","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"1b6c7469e60260882f119d13ae71c900c307f91594bbd9f2bdc4e6da36ef0f92","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.root"},{"byte_length":19714,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":18641,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd","sha256":"806eb552ae1f507eaf5cca4748292faa2fe970f474b352f968d7e949653e844c","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd","sha256":"a39a1ad2a60c3bf9ec4fc1423399b6b4ca2f01ae4eb41391915266fbb8f4d08a","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"11f26ef2c7421709911b32eefe9662ad1b44acb6c68799b0e3b5c785993668b4","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.root"},{"byte_length":46481,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":45654,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd","sha256":"e91efc9e6f956c1dfa37483d0deb701076a8d792b85b244df36d2545fec0e338","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd","sha256":"094fc8463139a21d29f91d7bb97bfa645260908e597658cf6ce695d2ae4f774b","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"279da597c3b8c76a0d351ea80a7298a35d06cbc1d5fd5b455d972e0dd11e09d3","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":14316,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd","sha256":"2c21b504b0d9bcaae9369c5274d602f8a78cf14ddb46e85ceaf31ef659393b98","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd","sha256":"67b219ac633d585f0614b6440e7f35351269c31ac3e4cabfbd488a0fb9da4533","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"619d84422924c6f935694546c09a12ab8259a900a4de858ca0a1440cdac95039","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.root"},{"byte_length":7971,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":13207,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore","sha256":"66bd36a17cf6d3b9e298380bb3b12b8e5611768ae90f08844550c5538f08d5ce","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore","sha256":"22d254f38d45611cbaddae87763dfe9c69d27f60ab094ad4d00e95f385aaa144","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":13198,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd","sha256":"222788ec908aff31c1a1e0887d31caf632617664527c288457e02e26bc12af44","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd","sha256":"8f24b7fd2961257976ddca5c9e7150888e6d8fa10d39fb5e9824b5f5f8984aba","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"c519ba57ccc3d8c9f878e881f81803e4b6b81b71805e086f3607f6d06641ae2a","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.root"},{"byte_length":4871,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":13231,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore","sha256":"31f1a24e8a3b1803b1582ca187f154f168d4de50f4d158cfefcdcfd14cbd91e1","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore","sha256":"fbe709a7ab05c1361a2e3f37d3efd1eb679314baa9cb3c6c03e6ad676bc4dfe4","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":13222,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd","sha256":"b17d81507821a42557a0d4d68989dd9d8030cd89d34aaa14d677982c676b2aaf","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd","sha256":"78a1ce3f5d88035dccac66aa31d8f46cfb971101d37c79a643dcfd4f92edb695","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"615133adeb1e11ca155e36777a4a9277946b06a8a90f053a8411f2dcfedd6951","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.root"},{"byte_length":9164,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":17187,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore","sha256":"6b383060c5d4fd76e93db5e6011af28c0014b5a0132a258b7ae0565a6a423409","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore","sha256":"e2cc2e022a86b8de1f09606e1421f412b7571f1336d7805ade3f549d23d9a081","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":17176,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd","sha256":"f0e787b61cb72016c33d3b875de6a67bdff1521f71616c619d5f3b76cda472c4","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd","sha256":"a73c64c35e491e53cfb1e0e449d17461eb885b9eb90acc27080fc9bbb9d8dfc0","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"e7a480dbf8cbfaee18e22798f6b8e3823ab43c0451400647bc512f83d68c3f8a","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":17051,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd","sha256":"1123b7e1ae9bae4fe0c5e30f4036e9f7d159317eec39d753bdab7d81c67d8607","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd","sha256":"dd6b13e89e0d480bff835bdd6e2bddcfda5dd88039a86c07ab0af57fed11f35d","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"4d00f902be1b30c196fed06b12f4a19334c25b4e3d7d5baa848bcff073cc13ab","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":23308,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore","sha256":"8d65ec9db0fa28d69171e4ebc696293cece1c844dfb02a7af8ba496da51c3786","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore","sha256":"28ab2486db6b44122a5717e84da4c2a3f9daed111d641799960b7a1ecf568dbf","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":23293,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd","sha256":"40dbf6c6d9b0dd7a0b2e011fc6dded4a428eab6d00abc502228eb2396d141e68","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd","sha256":"2fee1aca838e402e24b7c163ab43eaf8bae04a4d062a1ed1f707a757ef196cd0","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"631b90ae1be1c5757e0abc68d5d0305e330bd80376b1082e32cef334015d6b17","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":18151,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore","sha256":"9b9352a8daf6b0705085571fc728df5f6d234974a3d0f3329c17b611c5952e66","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore","sha256":"acb447482f1c029929605c1c3ce751b077526d4b8820cdcc50d485e827d77614","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":18142,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd","sha256":"d475efa2ec1b8e30b73a613e39906aa15127adea3d84f0b0d09857e331850d6d","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd","sha256":"a99e9e10bd1757bf97a0a1cd8a2ab5fae96470878304608ca5d9cfb863da77d7","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"931c9d5ce6c89d9c9b1e0c6d16c1cfa91f2ec97e9ecb1f92617596af5a5474db","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":12290,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore","sha256":"8fff9aa49776d5d7d9315e8d8c1b8bc0805312d6252fcb95321f71f2577e3122","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore","sha256":"92141d337e4407fa7b8373b512741f9173cbcdccc61ac3bf04f9022a43268328","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":12281,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd","sha256":"80759f54751ac60159db8967c1b5d110a059f7ab7b2b84a7edd5b8ef4a1591b0","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd","sha256":"0e85f3910b78549a8322c0dc914d9ca27964440d5a9f1b13a58db00939888258","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"94ca7673d217f7f0fad7d44ab9cf19d290a62977475a399f3d5bd8bf7631c7ac","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":15180,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore","sha256":"6b92197db9caf4605a3885877eb8eb51f3f22a187456d4ea3a2c806aea8e1f48","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore","sha256":"911371599e9364b6cf0703cbd21595824c56e50597d2dcd183062c342bbf748c","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":15171,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd","sha256":"a4e20fa8d3e8bcaa1bffad4953b5f73a4676d296b268d5875f6cf15c4de1a42f","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd","sha256":"cbae64cfb54b4db27d4234d2a619f91d560f607bf41a3ce77ee2d0ce18377bba","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"9d5ba534d20d2da4d7559cea3557e67fcb8b1e11399eb31e3bcd78d778a2dfad","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.root"},{"byte_length":10732,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":13223,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore","sha256":"5f808efe39a388158c6b6379cff00941bdc0b59d0a3e50bf0240a99129fee7d2","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore","sha256":"3eda29f74c85430085cb3629f22b8c224c8d0dc9949ad8b9b1e29f25e91fd9e9","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":13214,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd","sha256":"abf5079bebd80645bc88fa5da020559451e6ac08c0914f258bb0915d8a20265e","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd","sha256":"1e85986bbeb7e84131ca99ae417932eac923524e315ce03a311549c8faf5eede","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"27a03cd1601905831431712cf50c9bc4718bb2ff2719a895c734873f4a285793","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.root"},{"byte_length":8621,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":13594,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd","sha256":"39fbd9b5b14ec9d578ccd5d46c1c7c47086893b933c40b18e94189c496a6c0b1","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd","sha256":"eca6069661ff148c38b61c9ae2a3dff0b9fa5344c53fb3fb94fabe7167abb704","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"f4c302a664367255c2e493da37157e3072d55da82070700f037de4f1f65fc0c4","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":12086,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore","sha256":"c02c5805722fcf54fa70a66f1b521d3284a6f488c102f45e39a8375176af759f","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore","sha256":"0eaf37c6da80d7acf13bb092c62c4950462b167f8458465ae006677168346651","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":12077,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd","sha256":"9d529e1e95f2338ffddf46b3e8d1cfdd120e40251b80557b8ff61708bea4ce77","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd","sha256":"cbeb8e2a6e317e6b9bad25497319ea0e840d86291db1d8ec83aca50fab895c66","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"5bfdef734ee34c48b53c18b7a5700ddcec819fd11b2fd7de2485fd197327ec66","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":13587,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore","sha256":"690d5c56a9ef73cb7f9522146f90c4eff6b29ed55e01ccd6ef39c0067c554f91","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore","sha256":"ea1fa551363c3106f6f2810dc9444ae1d84d8c5f85ae16a6e960db0e63e0f87f","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":13578,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd","sha256":"901e23b79ecb0d2a67b8bb48b0141627bd9f09b37d4b558d9b382d49ee7d8edb","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd","sha256":"817fa14e2c7b6b4e2defe29707880065fcd2d609ee9d5451a31c4807990a1504","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"489005a7f5d2aa43e1686f68567b84d5d0f561a6f4f77fb2652c00ae65cb6064","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":14419,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore","sha256":"bd1e2247893f5d0081ee1c3336db80135d2bc58e0ebe6631479bcd85421a957c","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore","sha256":"85637da1bf034d40f89fb0835f2c2bda15c1285f2e12d162e5856910edd653bf","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":14410,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd","sha256":"344390f701cc8439e7636979b7cdc5f2919745b2345234208bd915aea3fa4428","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd","sha256":"1fd7ba777f60362a68478c3c5dad30c60c859421ccf2b4085345d073f0f8db62","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"2cb6ef46e9a6ef78279acab6df365a8661b8d8abe3b3d843f0744c553bc3cadb","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.root"},{"byte_length":8520,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":15652,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore","sha256":"8b2c56e465c82173fea6f260a8baec930b065cf41f1f069f34de0786c88dce97","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore","sha256":"3beec9596eb3670f61bb38bb108b69a45d3e73cdaad1e3b759c76833c93e10d1","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":15643,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd","sha256":"671e2e4c9130d2d058fa61da60fce5a47a793251ed06fb896c7e18b985b8706c","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd","sha256":"464479fbcd54d3641f6c6f826c76622ad9cda2ce5f6e3f00d169492f745c1e3d","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"2f14f1cffafdca14966293940d5f0c29905c8d5c3e90afdbe6d55183cd43fedb","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":15730,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore","sha256":"2f6881608b342e2f39fec0acf1e1cb00bfc624f2f478c7a63d9ea0f504b97d6a","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore","sha256":"9f95b7b4baed019426b978c9829bdf39ff44dbb5c771ac86a8d66b84c4afe214","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":15721,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd","sha256":"98a39db94a080bb30924def42dc4a90f155406292f82ae9b0dcfc28dfb473d1a","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd","sha256":"ebe803a47fbf587e422801792b5b4d184b4766e89ab4fe6c3972593ba5de0de4","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"e68bc97750bfe257e3475c8e6f999a07335cdd050e7f31ef8931d99d3c0bc03c","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":14299,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore","sha256":"d77eedcf5ebcbd484f4ed46e812674e8d34986dd73900d937d545bb56b705577","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore","sha256":"632eaaa1f03152b4731fb15f403a45f0f9c555c44fa42db76f94e7e1842e0722","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":14290,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd","sha256":"1b40a8c1073af40c7dc3c834b94431a0803ba505a3de925b9f23ad952ce108e2","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd","sha256":"b725f59e6f933ecf3127f2fdc39187027f5fd1be31e1a25d5a19f8c59280d0e4","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"caf613f32eaf49b7bb61936e9dfcb74b0c98f493d600f65b79fcd8ac144f2f48","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.root"},{"byte_length":14059,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":17651,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd","sha256":"dc048108e269b26b68a36a5418aaeba9c638332978dfccaa3e183191aa453b44","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd","sha256":"a7d21c4c9ddc58cddf295959affd327ba8d499b0097e815fd59a81b121ca1ebf","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"a7de015a99db364615a3dbfd2db2365096ec991ff21fc161016b8cac8cbdacbc","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":12362,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd","sha256":"6ddce872431144c987261a2e81d215204e18f4f348332842f729ad538f6f9177","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd","sha256":"eeda4c12c5a055dd1ae66d4f3ddc8973335f5418391fed82f4f56fb43767d02a","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"819661e921ca9b4cd0b4f917cd2ca14c43c42f6f8ccc96d38c467df9eda738be","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":14110,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd","sha256":"122d40ee3a327723f1f6da5a8c753bd4debe76c520e33552c0a6713d54a7921e","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd","sha256":"41aaae07b5067b3c6910e6f2a04834f9bf32bc360cacfb37960af763af50bc0f","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"dd5170592b12eff12b255de0c118850d9f0d7b9d687df1c67dee014c12924ee4","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.root"},{"byte_length":11694,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":13973,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd","sha256":"05360bfc5b3ae7b25923244739f51ea080806534059579d172bd3cb44435d4e5","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd","sha256":"259074ca57592881f5070ec73d50e04692774ca3e203dfe98f0847f005f9236c","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"2ef11b293fd7305ad80e65d5faa75bc6ba27fc34bc35dad60f3755dc9b052db6","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":19612,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd","sha256":"38c7d78044682be475ab17cf996128e8fe52e92fd1c4fc87c0d31965428d959d","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd","sha256":"571c245f79ad4c331d179f4ab9e4bd2b47cc66627faa97c8216dadcab163c3cc","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"0c5e31ccebf374e411090ff87e8543b6dfb89dd1525ee15db22c4c67041aa744","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":27393,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd","sha256":"2c99e7e674608434aa4ab2fd0fb793308c0eb18393f780547170e94cc63fae65","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd","sha256":"b7aa67521434515c0cebc73be3a0b6d6076b6381612c74bc79cdd3d664a074fb","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"1be055773dbd067ac0c2d9930b95123497eb5dafab0ca00c5b24c81ac7b98f0d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.root"},{"byte_length":17232,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":13329,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore","sha256":"bb476fffac736a9fe112b821f125d33d461a9febdcf5441d7dda5ae290e46e37","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore","sha256":"ee9c70d3844a2bbf05e09fcfdd3243702119b4fcdc1d932f55154e7023065b78","target":"rust-core","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":13320,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd","sha256":"c1af99858958feaca3997004349e80100c155c70ec68c1a1ef833eea3cfdc8e3","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd","sha256":"637d7b5c691ef9b9dbb117e0785acbdd9c51f920cb17cd2c375c487af0329f28","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"8b07d57b2e649b0a0c6aef7af5d3d94b11f792b17338f802af144d04bcdb1099","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":16990,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd","sha256":"772797d03c1f8e4926b497485fd293f68dbaee574c84353e72d1fe5bf15391d3","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd","sha256":"763a3836669d79aa6de40bc32e5c2afb941ede8fc19cc513b3febf3253a1026f","target":"rust-std","theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"a58db4a7fed487f3f59fa358a632d2246e219d2f24c751dbfcf22756dc95fd2b","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":57998,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":57221,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd","sha256":"16d39775a7cf3b3dd3f9ae5d12375e23b1c9dfa29ee663cb2577a2b7caa866ec","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd","sha256":"beb89f762c69fec72bf9a78610513e1e66fd5b5e51ddc3188b3299febc1c0b3d","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"b4588ab21a3f809c11b483a84d58f7fc414eee24329843d30bd27b62be393774","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.root"},{"byte_length":29473,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":21729,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd","sha256":"053437af7d054dae3b840ee9bb117ca30482b31ff282c5597a36b4f632bfc222","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd","sha256":"5bc42a07191c2a1ede7544dd1c30975c8ea3bfb07fbce0b4eaaffc5bd85de72f","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"47c1c2c1bf7d795357dea0ee35c7928b038be267e6058ff17a107944aa11343f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.root"},{"byte_length":13128,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":19445,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd","sha256":"2280f6759cd5ac8c0b600c3ca25527117285ac8a441ac3a1a53da0469f7e33a9","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd","sha256":"88d316c92d1a6ccd57b34589101f2a998a40e66f81f0eaa04e32d66b6d561b17","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"d815973724d8121311cd68afb3102c3271ac82e79d33df48e32f1b2e5d702c77","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.root"},{"byte_length":26754,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":18245,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd","sha256":"1c5466dc8a352924bad0d7e0699faf513c780fb3b8d8b5f0e636820f24805cd3","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd","sha256":"7a84de1f29906d5c464e662accdc73056b8793d53adbe48327b6075fd892c0f3","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"0d076d254db8396ec78b2be79ed08bf1f57116401a33f5255d895054cc793213","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.root"},{"byte_length":13311,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":17987,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd","sha256":"3ef20522a67a3518d4c33dfc02c000af04959dde7e234751bf5bfb7b19bab0bf","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd","sha256":"ff0c63d4985e6f266ba8a5edb3a5e2aa0d47a05c7eae6b01fbff192ea048d622","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"c839da53a3d1f606fa20561089ce6b3f2216c8df4abdd7af827e1e7cc66749df","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.root"},{"byte_length":9201,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":13364,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd","sha256":"efd13e9afaa3e0ff22ede2716640375e990c165d97b21e591b183f7736474f8b","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd","sha256":"6f3d755367df1556aaa577970722c3c25a6e9123a4f3d2ec66333e6e906f7bc9","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"9de0747b5c693a9bfac29a23dc04c7abe95430fe0712e81b66f6f39cc86c9940","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.root"},{"byte_length":30366,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":20096,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd","sha256":"6fa3d90612e26fddf0f86d0f2f23946f725c312ef3763a88cbbbf721dab22269","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd","sha256":"5d36bd019eaf999c902eb20e6e7d98721d20583243f2c27f44d4851c148069b6","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"463eb1ee477a68ff137ae77d5571ce2fed336f83dd503cec7a4fa0c586d9e837","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.root"},{"byte_length":19714,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":18641,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd","sha256":"a0f197f616b7c29c49bfbf2b6ad06daa30fc176c5f436ec7cdf4bcd963a31503","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd","sha256":"25ae3aed96aec689469f271ae42b2cb987995b289270b71d63b1c06d0489a773","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"7cc6bcb14e7f5cda69e5c391a040aa054c5b34baee7bcb7ecb550f733170bab4","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.root"},{"byte_length":46481,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":45654,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd","sha256":"28f74f0c0bf29c07fa97b652c3daa5116710ac4996e8aacde1b5aa8d67df9218","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd","sha256":"41a01d4ec494086ca421f4b716492c0e8a7c3e6e6387f614f64be811c71dc509","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"d3ed2df2946e2f5475fe31cf10998a1bb30566b697b1e22e788a41abc7611f5a","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":14316,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd","sha256":"c18d95505fa7834d9cdf57351175579e01778f8925f461e6b2a01826412f1779","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd","sha256":"b030fdbe107fa547180a8455a071bcf8c1ecea03859c08b58cf754baa4e5ecc7","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"91a016c2be5eb1e8d918102926352a842f0a0240b47c370734c886737b920eee","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.root"},{"byte_length":7971,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":13207,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore","sha256":"1447fcbc3b3614e7fcba56331a7871f774283ef10bdc21cee57bfeb8688d3e8e","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore","sha256":"98e417385c227b9bec9a25856d84634e806def73d886c44f5a95e48998f95fd1","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":13198,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd","sha256":"c59c1671770a10f77ef44206a75da582f8dfe8db5a8f2e06aa1d592fc9d77ef5","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd","sha256":"1d88056344a16637696154c46154dd659fb8e8d62059055fd285ef7926a9a832","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"561476c55d68a76a4588baa246b58b8358411a703a735c0b7ff82d88ae622881","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.root"},{"byte_length":4871,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":13231,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore","sha256":"0eb59bb2be114c2d3ac92a04f248bbf474a0136cde874439deaf58004af5f3ec","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore","sha256":"360ce2a9538d24ecf3e3e4f9828ed44083081046de26f98db1f91dacef760b40","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":13222,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd","sha256":"da17fdf0e1bf5a6e17e41f666d7c2a9b49f20086fa728a3300d64574c64a72bd","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd","sha256":"2d7dff97b103bcd287b44089e70792d4f4ff753c636b0851a6bf111aff45286e","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"a35853a74247372eeec48dde9fdeb6dbe3a4a7f9bb1db3ba6d61637bcae8486f","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.root"},{"byte_length":9164,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":17187,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore","sha256":"9fb9389dd3aa98b258c9a4e630f5ddc668f78060c81993cf47bf72b7d7de4111","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore","sha256":"834879378edfd13d752a592798eea4342faf93d7c859d9f27328163e59a11bae","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":17176,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd","sha256":"99d8d605367a791bc10a8d041dc42daa97840db190e750683994c83e951f779f","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd","sha256":"fff6b1fe082d4a1f7d3c999ce4ee51a8af34626850ab927d4370139cadc79bf4","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"c16c7abd185a4f6a9a37bbce1da1da0d3646bc84d5a3d18ea287c9a34b74744f","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":17051,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd","sha256":"f7177d6f6eba397fc48f397d908552a731fa727ef948ebbc960a35113319d2c9","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd","sha256":"609fc21489363185fd4fd8e175f0327b77fbb27865ce74c3bd07f39aa5602453","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"3e225e6a6a52a4a20db38ce515cb7d10c937a321ecef6f9aa3e1b57c78cac0bd","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":23308,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore","sha256":"5fac5f59454b9b486823c42390f9c608ed99ef5714f20bb53584acb2a1cdd3a4","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore","sha256":"c1588bae32a6e390920a9ee5b185893bc62a11e2a2f4949bff3f1be6e6e9a65e","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":23293,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd","sha256":"f9474e7c81976124950d370699d0260d8fdac93d77c3205f655e19de984c2a57","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd","sha256":"c296691a4983b75523c872aa82c6a670275c27ecad1eff455fcc848c05c89e0d","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"2d4cf5dd93438624cb30fbad33497a9585ff46d77b7a1c2870a92947f7d3c73c","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":18151,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore","sha256":"8b4d447eba1c2e3862db72056ce2b35d45d6bd61c78b8e089d894d68f05994e0","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore","sha256":"37116ec6408b337832dbaaeb9f7191e6e11e4168100645cef15d9af221f3bbf6","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":18142,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd","sha256":"fe877e06d3b62e17cd52b5f82255aa559726c53fa351f30f03c5de200e9d1ec5","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd","sha256":"49a39eeaa87b7297eb63e6e3603c7e6bf748076f3974bfa8f5322fa576915b1c","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"bbeefac15684adae85c2d6b07379ac0c418dc77bd0468eb718342dc7c6f62ea7","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":12290,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore","sha256":"4e36dcd1fc493fa6adf89ea31003a7cdf614478e9683498fad3a9d1957f1b4d7","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore","sha256":"c894f2d39488ea9d88cb353ea70413e361928126f480bb5f8f57fcc676fba1eb","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":12281,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd","sha256":"cc4fb13f08b026957def308628b2655c81599fc823e3a09b182dc6d8e5cc19ae","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd","sha256":"5554f610b750a6f7d2bce0d65daaa64bb43cf5d2bec4f1652905ca06bfe278ef","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"b0c40a5072fa493a364764c767b52c4831b0cbece6bceeedbb60695b5f87b674","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":15180,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore","sha256":"7d22e9586c1743d738b40859b147aa0dea8e32c4f6ad7fe1baa28fab826c2ddf","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore","sha256":"4a3cf6c3bcdd82c135e769bbf5e7d85773d402a355baf45a47d61343a49c626a","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":15171,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd","sha256":"9cbe3df8e69a9831502d5c98564615cd85e1b9d09c69b3484b79371b1d2985f6","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd","sha256":"905e13e37af8086888fa6f6edff838cc3f1aa2ec33c1dd7b46c50bf9dd20ba6e","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"264be0fb3e6bcc9e0dd4c5e12c26fe39ab13f1a495858bdb2b2625bee4166456","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.root"},{"byte_length":10732,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":13223,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore","sha256":"dc1a13693ec8d4ed28d14ac1f2aec7b02f88afe61a5030696c7e069be0ed98b7","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore","sha256":"8c0f0e4cef65831745a93246b0014d713ecd7116903c7ada6cd85f9b8e9f37ed","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":13214,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd","sha256":"990a4cedfbe6b22092b12544ab3481e0a6944f57d56ed6bfe1715085add8f2b3","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd","sha256":"a144da54278fa38a665f895abb90e6e4868593e0bf91f2f607bcee7772826a78","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"3ae253975e92896e980899f18979eb52dec9e0f40c6a3ed78a5189309ee825b5","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.root"},{"byte_length":8621,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":13594,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd","sha256":"cfd914aee605cf0074a554f1cde25456287afdc1f33550c7fde348142e3a3da8","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd","sha256":"05de0dc9402cdc13c8d513d91d4d4cfa0236e790b6c126a25c1cdcb850faf3a4","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"c11d523ee86ee6fb307a5005d640e56acb702ba809d812b62b1a1a575d36f01e","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":12086,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore","sha256":"2269075615ad3dc3be4027776f2d11b6d5499d386edbf83956b0d5db310131da","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore","sha256":"053177d6dfeb2ccb9bb14200baa6ec774e5061172b3bb1e991c2471017d6b25a","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":12077,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd","sha256":"ebe1e0c7a60ef3018b1bddd5e791a1a9da7471f45cb97b3c03f27e1797db596f","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd","sha256":"f449debf270c78499303a84abef495d094f5d0348d18ab2985ed4a4227879b12","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"00c953490ad0b23892b72968892d7eb3265260b90312ccfe82f6a1a7cfbcaf35","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":13587,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore","sha256":"f72e63472f70a9917e8baa7be15c503626a25a68095bbd16303b63938441cb3c","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore","sha256":"ca7b61e1fa20fb1d88128a261e4c368f8f6f64d2bcc58a6f38a4576fb2af83c6","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":13578,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd","sha256":"c5209d7190738c19e5ef94e44b8516ca6da0119e3cb3c175e49f2d0cef391141","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd","sha256":"b69d0155af69dc16509b0fd824d84e91bac2ce901146cfab900b59fac987e38e","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"b6ebf05a529909b356a31db1586360b48ad34fd7059ab68977639a52fb4edbaa","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":14419,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore","sha256":"916f5e75830a5049efefcc920ae440f087f2ce3ce807cfc8d471b8b8005f2bfc","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore","sha256":"01aaf3b9fb3be0817a9bf9e7c03599fc0acf2e1ba0c5762a4acb8d4b4085adb1","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":14410,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd","sha256":"0b43dc81a7e0cec3f9bc0c3bae377297bfa5cc5853b928f447ebda666b7a50b7","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd","sha256":"d18d06766b3c0bba8d0e6648a97279caf82f2a8bd90942a6bdc14eacc0b44e54","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"c8f6832526c8de09cf54c5d9861698923f3c4bdc485062126d4f7c70f4cc93fe","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.root"},{"byte_length":8520,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":15652,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore","sha256":"777663db99fe95472f1d25fc732997a12df54e18fba9a847c5268b44b11309fd","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore","sha256":"3f2270924061f724e5341da29a78ea107f595fc322fff922de4e034b5398032c","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":15643,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd","sha256":"c91e60dd9b3b288171690de5f09c10d62e3bf2b5d07eae73ee9ed55464c9e10e","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd","sha256":"21073f0acf9f769c1b473dba79f90a2297a931e4c05e44916f03c6a9c32de91f","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"56d3eaee112114bbaf2dc2ad1f8b74a8f57b8ad94890182652b9e65deaedee73","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":15730,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore","sha256":"f71d03cd039c508f96fbebf3fbf4c69bd2eafdd43686da81a39418df24617ca7","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore","sha256":"16e071c5ff73ea61a70b80b14269d904b7e2b9797c0dc679f213ec190abc5841","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":15721,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd","sha256":"f6387dbfdb811f9c759b5f87e1ee458ed7bd5f768eaa42cd2c19964a83afb47b","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd","sha256":"eb098e508a35789c2da6fb4ea32e73b857d311816a1a99cd97cdae61e4bcb87c","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"4bf4de9e39e75702456c713b853727c6905aebc3b5a7b32d982241e31ebe3eb5","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":14299,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore","sha256":"d20da1def253686a4dd6cfca7e928905c2fab53375c5dce0b68eda074a71e4d9","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore","sha256":"a7c303d0cd089edba8fee58ca6e13d7027367027ed1aecef0f969315632749bc","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":14290,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd","sha256":"bad0225ad42fbac6591d03580ad6e679b70e10438ea20e4d8f11c4126c826fb0","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd","sha256":"00b72f07ae13069e4e382b011bacc0ada63d170b0c88542a23c58c5763e0d7c9","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"a88cb58fcf28b55f04a2df0bb306512f60dcd99805c5f5768b2fe80c7b75cd3b","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.root"},{"byte_length":14059,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":17651,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd","sha256":"2725219c8daaa666815dff73fbc73ae0ae341219cddd1873d40e8a67bd16b02c","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd","sha256":"fa952416e631f18ab17c93317fffa22a6e47af83d382d977114a5d4869307ca0","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"b930db2552f5ddc54f1b5b590af9a150727b6e1ee87a8d594459123c9f6ee246","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":12362,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd","sha256":"f14b07899954c6ba37a1446bb8f2c752ecb25685ef35049e4b7380a03510ebf0","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd","sha256":"8ee66483b84ba34a7fe3897aa9f5dfc0cae38fcad8932e99b647e175a0eac78f","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"6ed895951d7a994f8e10de3004f723ebf382a470a8d259823f1dde001f81c612","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":14110,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd","sha256":"b10964f6d6ba100400a5c22d1e579c38c49bd11339dbae2c3c6c08f24532ff28","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd","sha256":"438424192056bb706df35f2040b738d60574465c740b32bfdab0d977cfe5bdff","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"5ab48a0c4cd15cf51d68cab63f119919eff5165d202d0fbe7dfa066edf61711b","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.root"},{"byte_length":11694,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":13973,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd","sha256":"30230753eebd26c468b476a94a3e1cc3929860ab2ce3ace29872251aaded4095","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd","sha256":"14a96961596e8be388348529eba7732325feb9798ec4c4f28d0bcda9e38b98be","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"c6fd64105795a2d787dc4b00ba6a4f87795c8dfbc49ad997aa665c8b234d89c1","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":19612,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd","sha256":"122c3be8ad9cab47ac393312bff323e8232bcef0ac3ea1a4ca00f5e1b103e1da","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd","sha256":"368bb152a9658bd55d49d00b90faeff3425b5e2832e4434cb20dc68f42935fa5","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"7b7fe303e6bd5d42d76dc376ab69e150c55d13aba8111827f8a501d8a93f7b8a","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":27393,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd","sha256":"b928563774c1b4d597f3c9cc63b9599d184a0ad157beddf1c8e7237af94a9ec2","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd","sha256":"80042fcc0b62c48667d3999e7e674703649bf6bbf4dd6d5340eb23eb9065a397","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"1f9168fcb6dbbb2a615ca9aecc976e6b23ecda16bd7c7e7bd684804d5a8bdf17","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.root"},{"byte_length":17232,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":13329,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore","sha256":"eccfd6321739278330ff50de08d79c0e395b5f29b539cc4adb10de61157ae26d","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore","sha256":"43ea4aca87af6a47860857a3fddbaaac30b7591a47cea4197b586887e366ede8","target":"rust-core","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":13320,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd","sha256":"2e5185e611c65d40cad9af9f34f070076aac06749cd5c0241fb0dd34f659e799","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd","sha256":"8936ba4a02cc0f2c5bf0047297e66c3a7e3e93e21cfea1c4456fa40b54c1c964","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"c4848159695058b0ab88dcec5b215dcd53d82db2e7c437bc3b37bfb0f24d2d09","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":16990,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd","sha256":"cf72917d55a8dacf864e3dcc8935f126b1b7fc072f69d0fcef3a727289788d7a","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd","sha256":"373c06d76854d5f39a4e6004d8b4abbaf1701bc8840c2a3cddee5edf24411802","target":"rust-std","theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"e0dabc10f6aa17a0ceef18ddad820eac9b5251dcfcf7daca8baf46ed3ab75578","targets":["rust-std"],"theorem":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/production-coverage/expected/verify/probe/LexLeanProbe.Pf3572b43e36d5c62b7601d32507ebc3a.lean b/examples/production-coverage/expected/verify/probe/LexLeanProbe.Pe05bf7cb47aac48ea11c4a7ac75c7962.lean similarity index 100% rename from examples/production-coverage/expected/verify/probe/LexLeanProbe.Pf3572b43e36d5c62b7601d32507ebc3a.lean rename to examples/production-coverage/expected/verify/probe/LexLeanProbe.Pe05bf7cb47aac48ea11c4a7ac75c7962.lean diff --git a/examples/production-coverage/expected/verify/probe/process.json b/examples/production-coverage/expected/verify/probe/process.json index e8b8ae1ff..f98d74752 100644 --- a/examples/production-coverage/expected/verify/probe/process.json +++ b/examples/production-coverage/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pf3572b43e36d5c62b7601d32507ebc3a.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pf3572b43e36d5c62b7601d32507ebc3a","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pe05bf7cb47aac48ea11c4a7ac75c7962.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pe05bf7cb47aac48ea11c4a7ac75c7962","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json new file mode 100644 index 000000000..009d170a1 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json new file mode 100644 index 000000000..d1a225e09 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json new file mode 100644 index 000000000..32fd9d9b8 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json new file mode 100644 index 000000000..9d901a182 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json new file mode 100644 index 000000000..12020050c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json new file mode 100644 index 000000000..445df3681 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json index 0220eeb99..d4bd25289 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json index 259d5c54c..8d6b695bf 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json index d0b8ce55c..baf801caa 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json similarity index 57% rename from examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json index 7fe15b637..185394b17 100644 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json new file mode 100644 index 000000000..b78e91bb5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json index 4cc26a2ff..a07b1fe8c 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json index cf9384aee..281fdf197 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json index 1f62a24fd..606b8aeae 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json similarity index 57% rename from examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json index 12308846c..a4fcf332c 100644 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json new file mode 100644 index 000000000..94b0a1f31 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json index bfc5cafbd..400f3c64f 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json index 8ee6e3a6e..4e7de8cba 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json index 860a6b8cc..eb2ad9f06 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json similarity index 57% rename from examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json index 38264d20d..869e2678e 100644 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json new file mode 100644 index 000000000..b46447b1b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json index 26cdc92a7..8dcd7c291 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json similarity index 57% rename from examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json index dc9c676a8..48ab0f573 100644 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json new file mode 100644 index 000000000..a913fe2e4 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json similarity index 59% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json index fc2666ad3..ef69db157 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json new file mode 100644 index 000000000..d24fdbb2a --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json rename to examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json index 4a5f28fe6..808186254 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json new file mode 100644 index 000000000..158c951de --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json new file mode 100644 index 000000000..508e6f94b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json new file mode 100644 index 000000000..29cb3fd22 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json new file mode 100644 index 000000000..2218fb6bf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json new file mode 100644 index 000000000..46c69e483 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json new file mode 100644 index 000000000..9fa54fd16 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json new file mode 100644 index 000000000..87c334291 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json new file mode 100644 index 000000000..0b9362a8e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json new file mode 100644 index 000000000..1119bb67b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json new file mode 100644 index 000000000..8ea810fcc --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json new file mode 100644 index 000000000..97405b776 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json new file mode 100644 index 000000000..157fc4c8f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json new file mode 100644 index 000000000..c8c47f029 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json new file mode 100644 index 000000000..af839359a --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json new file mode 100644 index 000000000..07d2cfed3 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json new file mode 100644 index 000000000..a32f65818 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json new file mode 100644 index 000000000..8d7ce5086 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json new file mode 100644 index 000000000..038f40175 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json new file mode 100644 index 000000000..e5f40ddb9 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json new file mode 100644 index 000000000..eddfabe6f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json new file mode 100644 index 000000000..6c335bfac --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json new file mode 100644 index 000000000..30e5bd9fd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json new file mode 100644 index 000000000..d69741f50 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json new file mode 100644 index 000000000..c73548b84 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json new file mode 100644 index 000000000..616d70d42 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json new file mode 100644 index 000000000..1ff8ad534 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json new file mode 100644 index 000000000..15fa3f630 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json new file mode 100644 index 000000000..c10965cc6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json new file mode 100644 index 000000000..8e71eae3f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json new file mode 100644 index 000000000..40cc782e2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json new file mode 100644 index 000000000..7862532e2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json new file mode 100644 index 000000000..4e0bc6888 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json new file mode 100644 index 000000000..2122279dd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json new file mode 100644 index 000000000..5f9cefed7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json new file mode 100644 index 000000000..02b4ca8e0 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json new file mode 100644 index 000000000..b7dd4af2d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json new file mode 100644 index 000000000..3f7f96f5a --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json new file mode 100644 index 000000000..35b48e127 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json new file mode 100644 index 000000000..b3b88b072 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json new file mode 100644 index 000000000..279ddc03e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json new file mode 100644 index 000000000..773809bdf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json new file mode 100644 index 000000000..9998317ef --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json new file mode 100644 index 000000000..42dbaf427 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json new file mode 100644 index 000000000..3b0ce3a61 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json new file mode 100644 index 000000000..2776f6608 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json new file mode 100644 index 000000000..492ded7f8 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json new file mode 100644 index 000000000..33f914e31 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json new file mode 100644 index 000000000..43ab8fa54 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json new file mode 100644 index 000000000..af28fa730 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json new file mode 100644 index 000000000..35d07ea26 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json new file mode 100644 index 000000000..a30d4afc5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json new file mode 100644 index 000000000..000a581e5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json new file mode 100644 index 000000000..ebd369a85 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json new file mode 100644 index 000000000..cb0536a1f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json new file mode 100644 index 000000000..e02eaffd6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json new file mode 100644 index 000000000..87c1031a0 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json new file mode 100644 index 000000000..8053981e2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json new file mode 100644 index 000000000..bc3e39a1f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json new file mode 100644 index 000000000..bbd6653bf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json new file mode 100644 index 000000000..5de529825 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json new file mode 100644 index 000000000..70b7d473b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json new file mode 100644 index 000000000..25d8c8acf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json new file mode 100644 index 000000000..f8904b066 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json new file mode 100644 index 000000000..50a3af7a6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json new file mode 100644 index 000000000..87f82c53d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json new file mode 100644 index 000000000..e83d33e22 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json new file mode 100644 index 000000000..16debce01 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json new file mode 100644 index 000000000..a6f4e4bd3 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json new file mode 100644 index 000000000..cb4523e33 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json new file mode 100644 index 000000000..651cf4ac8 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json new file mode 100644 index 000000000..b6a5df50c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json new file mode 100644 index 000000000..7b3bb590e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json new file mode 100644 index 000000000..59386f184 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json new file mode 100644 index 000000000..38508489f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json new file mode 100644 index 000000000..b3ef29eeb --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json new file mode 100644 index 000000000..290ddf5bf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json new file mode 100644 index 000000000..c08153e2e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json new file mode 100644 index 000000000..54fb81b1e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json new file mode 100644 index 000000000..77cd1ac67 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json new file mode 100644 index 000000000..9f5caa2d9 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json new file mode 100644 index 000000000..8f5722ce2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json new file mode 100644 index 000000000..6c155aee7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json new file mode 100644 index 000000000..e3ab8a168 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json new file mode 100644 index 000000000..6332c68d4 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json new file mode 100644 index 000000000..8d30ea3c7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json new file mode 100644 index 000000000..49dc1add0 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json new file mode 100644 index 000000000..6aa82ed7f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json new file mode 100644 index 000000000..6a0717d2d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json new file mode 100644 index 000000000..85913fc71 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json new file mode 100644 index 000000000..fb04809b7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json new file mode 100644 index 000000000..012727e60 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json new file mode 100644 index 000000000..1d99f1c2f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json new file mode 100644 index 000000000..d630db0f5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json new file mode 100644 index 000000000..49331d349 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json new file mode 100644 index 000000000..4a9a75fbd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json new file mode 100644 index 000000000..c8d27f8a6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json new file mode 100644 index 000000000..ab0f71757 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json new file mode 100644 index 000000000..d65d95344 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json new file mode 100644 index 000000000..9a5ebe3ba --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json new file mode 100644 index 000000000..43866284d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json new file mode 100644 index 000000000..9fa453536 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json new file mode 100644 index 000000000..7e0484dac --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json new file mode 100644 index 000000000..1e74612c5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json new file mode 100644 index 000000000..330d652e8 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json new file mode 100644 index 000000000..ff6f52418 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json deleted file mode 100644 index c7f343136..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json deleted file mode 100644 index 11fdbc24b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json deleted file mode 100644 index da3fe905c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json deleted file mode 100644 index a6da3f441..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json deleted file mode 100644 index b7269a513..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json deleted file mode 100644 index 233a4453b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json deleted file mode 100644 index 513dc2337..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json deleted file mode 100644 index c53d03bf8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json deleted file mode 100644 index 52ec9ea1a..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json deleted file mode 100644 index 6bbcdf725..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json deleted file mode 100644 index e9c30d3c9..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json deleted file mode 100644 index bb1e697c6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json deleted file mode 100644 index a9638c230..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json deleted file mode 100644 index f239bc786..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json deleted file mode 100644 index 5690d2c20..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json deleted file mode 100644 index d685501b7..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json deleted file mode 100644 index 2de6caab6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json deleted file mode 100644 index 10e793644..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json deleted file mode 100644 index decfbc08f..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json deleted file mode 100644 index 9ff0e55a4..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json deleted file mode 100644 index a783c5b4b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json deleted file mode 100644 index 3918d64b1..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json deleted file mode 100644 index 4d163c85f..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json deleted file mode 100644 index 31636d8a3..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json deleted file mode 100644 index 83d6f06b2..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json deleted file mode 100644 index bb320324c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json deleted file mode 100644 index 94600cbc5..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json deleted file mode 100644 index 3122baa38..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json deleted file mode 100644 index 27d376441..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json deleted file mode 100644 index 9fd1eb7a6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json deleted file mode 100644 index f0ba41d8a..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json deleted file mode 100644 index 8611b109e..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json deleted file mode 100644 index 391bc129e..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json deleted file mode 100644 index bd44467ef..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json deleted file mode 100644 index 59306ac7c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json deleted file mode 100644 index 17099e9ac..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json deleted file mode 100644 index ba29ea628..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json deleted file mode 100644 index 5cf51ed05..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json deleted file mode 100644 index eac702e21..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json deleted file mode 100644 index 1706b0788..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json deleted file mode 100644 index f86f7c795..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json deleted file mode 100644 index 0f25c04b6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json deleted file mode 100644 index 104c271fa..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json deleted file mode 100644 index 955eabc00..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json deleted file mode 100644 index 4f59b47be..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json deleted file mode 100644 index 47b4398b8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json deleted file mode 100644 index 888b3f6b7..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json deleted file mode 100644 index cc4ec399b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json deleted file mode 100644 index ebb211d27..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json deleted file mode 100644 index 8afcacc58..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json deleted file mode 100644 index dd6eb2b03..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json deleted file mode 100644 index ebcca9268..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json deleted file mode 100644 index 6f53766e7..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json deleted file mode 100644 index cbb1cc688..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json deleted file mode 100644 index d97bd845f..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json deleted file mode 100644 index 455d2e4b8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json deleted file mode 100644 index 7370e329a..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json deleted file mode 100644 index 2f3534c64..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json deleted file mode 100644 index b9ca3f31c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json deleted file mode 100644 index 56bc97845..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json deleted file mode 100644 index 093d6ecdb..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json deleted file mode 100644 index 694c6bb61..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json deleted file mode 100644 index dcb78f364..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json deleted file mode 100644 index 4266faee1..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json deleted file mode 100644 index a8c66e249..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json deleted file mode 100644 index 8c7cb5e8b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json deleted file mode 100644 index 44720c7a8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json deleted file mode 100644 index 581403408..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json deleted file mode 100644 index 1ae362edc..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json deleted file mode 100644 index a33ba94da..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json deleted file mode 100644 index 30419f147..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json deleted file mode 100644 index 6a082c1e1..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json deleted file mode 100644 index 043d90067..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json deleted file mode 100644 index 42c525c87..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json deleted file mode 100644 index 48070a23b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json deleted file mode 100644 index d2205f94e..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json deleted file mode 100644 index 5f60b4d6c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json deleted file mode 100644 index 7473776c5..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json deleted file mode 100644 index 530e82caf..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json deleted file mode 100644 index c37f381ef..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json deleted file mode 100644 index 7ee1f60e4..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json deleted file mode 100644 index 4892207b8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json deleted file mode 100644 index 09bd1ebfe..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json deleted file mode 100644 index 6d7f63458..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json deleted file mode 100644 index b1a400dcf..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json deleted file mode 100644 index 9703b536c..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json deleted file mode 100644 index ce12791fb..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json deleted file mode 100644 index 37053c082..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json deleted file mode 100644 index a473d237b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json deleted file mode 100644 index 2768ef279..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json deleted file mode 100644 index b87f3205d..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json deleted file mode 100644 index 510969168..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json deleted file mode 100644 index a8d28cf66..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json deleted file mode 100644 index 0309888f8..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json deleted file mode 100644 index 1f63470bf..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json deleted file mode 100644 index 70a4e576d..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json deleted file mode 100644 index 8fe5a3301..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json deleted file mode 100644 index 37ae07eef..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json deleted file mode 100644 index 5ce890622..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json deleted file mode 100644 index b209bbd11..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json deleted file mode 100644 index f8fa3b574..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json deleted file mode 100644 index f322ed25d..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json deleted file mode 100644 index b7aac1de6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json deleted file mode 100644 index c37c7a5ca..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json deleted file mode 100644 index c9c494355..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json deleted file mode 100644 index 0ed4da959..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json deleted file mode 100644 index 82d0af823..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json deleted file mode 100644 index 75d20d55b..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json deleted file mode 100644 index 16ab35349..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json deleted file mode 100644 index 0dc443663..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json deleted file mode 100644 index 27ed51d94..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json deleted file mode 100644 index c6342bc97..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json deleted file mode 100644 index 45a9bfd03..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json deleted file mode 100644 index c4be440d6..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json deleted file mode 100644 index d75a7ce85..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json b/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json deleted file mode 100644 index 9f6d12bec..000000000 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 4b3a9b500..6ca5b3145 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"5bed72af47cfd559bc7aadd86b109f30a960c76c94ee0b36dbc483670a89c061","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"ffcdc7bd33da397e2017d44fc252f6c770b380ed88c3fba4705ef7727071637a","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json new file mode 100644 index 000000000..ed29b8235 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json new file mode 100644 index 000000000..0643ca62c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json new file mode 100644 index 000000000..1520a05bf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json new file mode 100644 index 000000000..390d5a508 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json new file mode 100644 index 000000000..f9b47f2e5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json new file mode 100644 index 000000000..56b9be340 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json index 973565f64..f79028813 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json index e91c34a12..34cd1bbd5 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json similarity index 56% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json index 21ca9ba58..cbcb47373 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json similarity index 55% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json index 1703305bd..26dc9f9c7 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json new file mode 100644 index 000000000..7b7c627da --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R10.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R10","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json index 68465fea4..8190ee33c 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json index abfff4ab6..4e2208253 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json similarity index 56% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json index 6845a17be..8725ac9b9 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json similarity index 55% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json index 8853d173e..0704f44ba 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json new file mode 100644 index 000000000..cc5f98e6b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R11.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R11","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json index 0a3f75f21..f7e3be346 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json index b6869656b..e87617127 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json similarity index 56% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json index 0fd0f275c..b049b6dcf 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json similarity index 55% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json index b1688030e..32f08dcf5 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json new file mode 100644 index 000000000..d6d56b0ff --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R12.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R12","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json index b13ff3308..0262783ae 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json similarity index 55% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json index 52eafa10c..1748660b8 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json new file mode 100644 index 000000000..d9896e920 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R13.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R13","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json index 53af78465..619d8d35c 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json new file mode 100644 index 000000000..d42a9da17 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json similarity index 56% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json index 426c0b8e7..57ffb8c39 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json new file mode 100644 index 000000000..6ad2d1256 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json new file mode 100644 index 000000000..e5935e9ed --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R14.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R14","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json new file mode 100644 index 000000000..e91fedd79 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json new file mode 100644 index 000000000..a0c08394b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json new file mode 100644 index 000000000..9a7336de2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json new file mode 100644 index 000000000..c5939bf22 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json new file mode 100644 index 000000000..1df3d41ed --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R15.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R15","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json new file mode 100644 index 000000000..aabd98261 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json new file mode 100644 index 000000000..e6a7565c4 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json new file mode 100644 index 000000000..edd0c15bb --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json new file mode 100644 index 000000000..c0a71956f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json new file mode 100644 index 000000000..25bd3f49d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R16.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R16","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json new file mode 100644 index 000000000..c1f4e3120 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json new file mode 100644 index 000000000..0e641da4f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json new file mode 100644 index 000000000..c6a691333 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json new file mode 100644 index 000000000..8062a1ca9 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json new file mode 100644 index 000000000..37bec9890 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R17.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R17","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json new file mode 100644 index 000000000..2ea3e4a1b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json new file mode 100644 index 000000000..b5a4fb56d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json new file mode 100644 index 000000000..33e59b79b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json new file mode 100644 index 000000000..806608afa --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json new file mode 100644 index 000000000..7cbf948e4 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R18.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R18","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json new file mode 100644 index 000000000..19e7ab9c5 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json new file mode 100644 index 000000000..3f7bb9976 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json new file mode 100644 index 000000000..02a60d87f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R19.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R19","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json new file mode 100644 index 000000000..90ce35f05 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json new file mode 100644 index 000000000..54d421582 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json new file mode 100644 index 000000000..cc2b4c96c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json new file mode 100644 index 000000000..02f9c2f47 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json new file mode 100644 index 000000000..42760faae --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json new file mode 100644 index 000000000..e50412e3c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json new file mode 100644 index 000000000..5b3263106 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json new file mode 100644 index 000000000..7f8047ffd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R20.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R20","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json new file mode 100644 index 000000000..8abc50e37 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json new file mode 100644 index 000000000..eda3531e1 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json new file mode 100644 index 000000000..75ef290d8 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json new file mode 100644 index 000000000..4885eac28 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json new file mode 100644 index 000000000..0ee47368f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R21.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R21","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json new file mode 100644 index 000000000..8a28261dd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json new file mode 100644 index 000000000..3a45ae6b6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json new file mode 100644 index 000000000..9f6f25397 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json new file mode 100644 index 000000000..0408a1e67 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json new file mode 100644 index 000000000..37b45fd3d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R22.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R22","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json new file mode 100644 index 000000000..e0a616c15 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json new file mode 100644 index 000000000..27f20d093 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json new file mode 100644 index 000000000..3d75af122 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json new file mode 100644 index 000000000..16b81527d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json new file mode 100644 index 000000000..09a4ebd4d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R23.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R23","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json new file mode 100644 index 000000000..f25b039c6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json new file mode 100644 index 000000000..617508fa4 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json new file mode 100644 index 000000000..f7eccf6bb --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json new file mode 100644 index 000000000..683c8b00d --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json new file mode 100644 index 000000000..0477479bb --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R24.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R24","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json new file mode 100644 index 000000000..1b96bba52 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json new file mode 100644 index 000000000..1bebde049 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json new file mode 100644 index 000000000..3d08a9eb7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json new file mode 100644 index 000000000..15cbe99fa --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json new file mode 100644 index 000000000..604067f29 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R25.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R25","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json new file mode 100644 index 000000000..d74b4c610 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json new file mode 100644 index 000000000..aea619dc7 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json new file mode 100644 index 000000000..d5fdbf59f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R26.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R26","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json new file mode 100644 index 000000000..7fbcf5246 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json new file mode 100644 index 000000000..c1832bf4b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json new file mode 100644 index 000000000..0e8ec558f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R27.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json new file mode 100644 index 000000000..1a29ef8a1 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json new file mode 100644 index 000000000..f0b9a98ea --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json new file mode 100644 index 000000000..68703cb16 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R28.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R28","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json new file mode 100644 index 000000000..986fc5706 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json new file mode 100644 index 000000000..ed2d1fdab --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json new file mode 100644 index 000000000..dc7127ffa --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R29.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R29","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json new file mode 100644 index 000000000..eb48443d1 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json new file mode 100644 index 000000000..5f275cf4b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json new file mode 100644 index 000000000..f931d8aed --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json new file mode 100644 index 000000000..4b934c59b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json new file mode 100644 index 000000000..dda819a2e --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json new file mode 100644 index 000000000..5648471c1 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R30.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R30","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json similarity index 68% rename from examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json rename to examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json index 360328d57..2ae30577d 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json new file mode 100644 index 000000000..733983d97 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json new file mode 100644 index 000000000..2649fe911 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R31.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R31","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json new file mode 100644 index 000000000..4426f037f --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json new file mode 100644 index 000000000..94ffc4063 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json new file mode 100644 index 000000000..a3cf25f6c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json new file mode 100644 index 000000000..04a2b865b --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json new file mode 100644 index 000000000..7cf71a7db --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R32.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R32","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json new file mode 100644 index 000000000..7b5d39234 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json new file mode 100644 index 000000000..bc9f69683 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json new file mode 100644 index 000000000..1c1efd4dc --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R33.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R33","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json new file mode 100644 index 000000000..b2d2b5ecd --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json new file mode 100644 index 000000000..757771164 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json new file mode 100644 index 000000000..0faaa9614 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json new file mode 100644 index 000000000..8ac497911 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json new file mode 100644 index 000000000..444c9cfdf --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json new file mode 100644 index 000000000..f7a71adef --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json new file mode 100644 index 000000000..1c12867e6 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json new file mode 100644 index 000000000..d00f73e97 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json new file mode 100644 index 000000000..5542a2a41 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json new file mode 100644 index 000000000..25c2584b2 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json new file mode 100644 index 000000000..f5511b55c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json new file mode 100644 index 000000000..ecc0b884c --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json new file mode 100644 index 000000000..460d1b557 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json new file mode 100644 index 000000000..dcfdc5506 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json new file mode 100644 index 000000000..8d5b15083 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json new file mode 100644 index 000000000..f1bfb54e0 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json new file mode 100644 index 000000000..cd9aac278 --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json new file mode 100644 index 000000000..43c26165a --- /dev/null +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9.olean","$STAGING/preserve-src/LexLeanPreserve/Ce05bf7cb47aac48ea11c4a7ac75c7962/R9.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Ce05bf7cb47aac48ea11c4a7ac75c7962.R9","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json deleted file mode 100644 index d01daf7e7..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json deleted file mode 100644 index 9df43a686..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json deleted file mode 100644 index 3bcdf2ff3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json deleted file mode 100644 index 7fdf2ae87..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json deleted file mode 100644 index 689162293..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json deleted file mode 100644 index 033859753..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json deleted file mode 100644 index d4ed6b6b3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R10.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json deleted file mode 100644 index 14723de14..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R11.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json deleted file mode 100644 index 4f250e7f4..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R12.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json deleted file mode 100644 index ad69f4a21..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R13.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json deleted file mode 100644 index 0f6441db3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json deleted file mode 100644 index e24eab849..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json deleted file mode 100644 index 47af5e344..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R14.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R14","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json deleted file mode 100644 index 08937ca84..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json deleted file mode 100644 index 77dd0bde3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json deleted file mode 100644 index 8c4446ef1..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json deleted file mode 100644 index 9ad3141f3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json deleted file mode 100644 index 3de928b70..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R15.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R15","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json deleted file mode 100644 index 53ee3ca57..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json deleted file mode 100644 index fa65ebe0b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json deleted file mode 100644 index 8f317ac06..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json deleted file mode 100644 index b36af649f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json deleted file mode 100644 index 0cb3d67fe..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R16.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R16","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json deleted file mode 100644 index b80f4118b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json deleted file mode 100644 index f90a0607e..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json deleted file mode 100644 index 7e9d2cbf2..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json deleted file mode 100644 index e254afcbc..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json deleted file mode 100644 index ba4b26261..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R17.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R17","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json deleted file mode 100644 index 1388154d5..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json deleted file mode 100644 index ac3af5190..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json deleted file mode 100644 index 07aebd180..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json deleted file mode 100644 index e9d6cd6ef..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json deleted file mode 100644 index 5e5d95469..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R18.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R18","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json deleted file mode 100644 index cc44a7db1..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json deleted file mode 100644 index 0e93ae3d7..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json deleted file mode 100644 index a7cf0833b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R19.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R19","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json deleted file mode 100644 index d8dd77b2e..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json deleted file mode 100644 index a43566a86..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json deleted file mode 100644 index 8de8f4b11..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json deleted file mode 100644 index 2ac886644..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json deleted file mode 100644 index 6abb8f3aa..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json deleted file mode 100644 index 636c77e20..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json deleted file mode 100644 index 4963a1adf..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json deleted file mode 100644 index 10b097e46..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R20.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R20","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json deleted file mode 100644 index 7d4ee375c..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json deleted file mode 100644 index 81f56df29..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json deleted file mode 100644 index c35293eed..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json deleted file mode 100644 index f2fefd33c..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json deleted file mode 100644 index e4263972c..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R21.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R21","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json deleted file mode 100644 index 1170b7bea..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json deleted file mode 100644 index 2241daa9a..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json deleted file mode 100644 index fcc6d0c8a..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json deleted file mode 100644 index 87fa66634..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json deleted file mode 100644 index 26c761c04..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R22.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R22","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json deleted file mode 100644 index c6f2600a4..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json deleted file mode 100644 index e786d96df..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json deleted file mode 100644 index e3945b4cd..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json deleted file mode 100644 index 2fbd10375..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json deleted file mode 100644 index f4ca26298..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R23.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R23","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json deleted file mode 100644 index deb8392e1..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json deleted file mode 100644 index 2efaf6065..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json deleted file mode 100644 index 27bed6814..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json deleted file mode 100644 index 1f1b7f4e2..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json deleted file mode 100644 index 8fbdf558d..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R24.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R24","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json deleted file mode 100644 index f4fd144fe..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json deleted file mode 100644 index c5249e290..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json deleted file mode 100644 index 6878ae67f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json deleted file mode 100644 index 2fab37b39..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json deleted file mode 100644 index d23780363..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R25.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R25","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json deleted file mode 100644 index f48e39b5b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json deleted file mode 100644 index 2580c434d..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R26.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R26","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json deleted file mode 100644 index e30fbf226..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json deleted file mode 100644 index 343a78201..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json deleted file mode 100644 index ecebb714f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R27.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json deleted file mode 100644 index 75b38874e..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json deleted file mode 100644 index 10f6a45cb..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json deleted file mode 100644 index 08ed3f4a6..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R28.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R28","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json deleted file mode 100644 index b6e62440b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json deleted file mode 100644 index ccbe31c9f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json deleted file mode 100644 index 7f5afd6f3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R29.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R29","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json deleted file mode 100644 index 74b9a5ee8..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json deleted file mode 100644 index 8c7fea463..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json deleted file mode 100644 index bc9f26c1b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json deleted file mode 100644 index 1f44485c2..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json deleted file mode 100644 index b1c7e617f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json deleted file mode 100644 index bfa300903..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R30.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R30","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json deleted file mode 100644 index 0f029d01d..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json deleted file mode 100644 index 62d8d8327..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json deleted file mode 100644 index 34ef570c5..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R31.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R31","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json deleted file mode 100644 index bcacdd9d9..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json deleted file mode 100644 index bbe10fc42..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json deleted file mode 100644 index 2cf7a9a50..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json deleted file mode 100644 index 51dd8b45c..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json deleted file mode 100644 index 72994996b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R32.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R32","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json deleted file mode 100644 index 1f28591d3..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json deleted file mode 100644 index ae9d5bdfc..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json deleted file mode 100644 index e14f02e06..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R33.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R33","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json deleted file mode 100644 index 814252c5d..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json deleted file mode 100644 index 05e85c643..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json deleted file mode 100644 index 1b94dd616..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json deleted file mode 100644 index 9d134a349..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json deleted file mode 100644 index 0f8866142..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json deleted file mode 100644 index 0169243ba..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json deleted file mode 100644 index d111e651a..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json deleted file mode 100644 index 15e1b3af9..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json deleted file mode 100644 index 8f8719416..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json deleted file mode 100644 index 67ee0f045..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json deleted file mode 100644 index 39a2f5a88..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json deleted file mode 100644 index 7a911201b..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json deleted file mode 100644 index 36bea5087..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json deleted file mode 100644 index cad5435e2..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json deleted file mode 100644 index 154e0e035..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json deleted file mode 100644 index 958fdec1f..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json deleted file mode 100644 index 4396e93d1..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json deleted file mode 100644 index ea5824860..000000000 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9.olean","$STAGING/preserve-src/LexLeanPreserve/Cf3572b43e36d5c62b7601d32507ebc3a/R9.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R9","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production-coverage/lexlean.lock b/examples/production-coverage/lexlean.lock index 2f4ebd5a1..d3d90ba6b 100644 --- a/examples/production-coverage/lexlean.lock +++ b/examples/production-coverage/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "1bcbdf2b89a335e2e8685fb89b09d3c4eba9f30371947781755576f588df7434" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production/expected/build/manifest.json b/examples/production/expected/build/manifest.json index 01c226d40..db5b9f5c1 100644 --- a/examples/production/expected/build/manifest.json +++ b/examples/production/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"e8cec50a5cfaedc8a44430d39b937679235fed006ab8e7b85b6447f539051b3c","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"7b10180ac8efc255555bb2a4d22e07cef3c3e29ef41f5827bfbefd38e55f8c35"},{"byte_length":642,"kind":"project-config","path":"lexlean.toml","sha256":"6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e"},{"byte_length":1946,"kind":"source","path":"src/Kernel.lex.tex","sha256":"a437ec054ba361d174f27a15fdbec5579ed2c841212e7bc0ecc659cde626e1ec"},{"byte_length":1838,"kind":"source","path":"src/Main.lex.tex","sha256":"0aaa9bd2649c30feb852481dd9fe94d94c473ea275bef51eb9d92237ba111514"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Production.Kernel","module":"Kernel","source_path":"src/Kernel.lex.tex"},{"lean_module":"Production.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":9026,"kind":"coverage","path":"coverage/Production/Kernel.coverage.json","sha256":"3ea97485fa3e255128c0e407a5c9bb0e24b55a2ba50111da3ce3e49a884141bd"},{"byte_length":9294,"kind":"coverage","path":"coverage/Production/Main.coverage.json","sha256":"eeb4778546afa3d37c1910a3fa60ecac720f3c72cccd005161392751d7da275e"},{"byte_length":4700,"kind":"lean","path":"modules/Production/Kernel.lean","sha256":"fd63ab40fb52b7c19c13e75eeef1374c4193955b214637e3096fa168c90bd3a9"},{"byte_length":1180,"kind":"lean","path":"modules/Production/Main.lean","sha256":"0141c5543da183afef9d568f1b0f2715a232ded8c936b6ea03c42d3abd98156d"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Kernel.closure.json","sha256":"e35a3fc5cf572b5924dcc9c94be8e299ee6d0504a814b35600a6bf96b2318c47"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":3900,"kind":"map","path":"maps/Production/Kernel.map.json","sha256":"5ef755f46093b700d441f34eba586083cae23d89bdf0fe291c2a90adfb9a196a"},{"byte_length":3571,"kind":"map","path":"maps/Production/Main.map.json","sha256":"e6d914ef9bbc2ecc797631839e766df1874ae42422d38275fe919c04aa320623"},{"byte_length":12235,"kind":"production-eligibility","path":"production/Production/Main.eligibility.json","sha256":"6c8ff35c840c08182f22729f284b07382ddce7f037e4aa40f3319c2fb61e5867"},{"byte_length":3394,"kind":"tex","path":"modules/Production/Kernel.tex","sha256":"d415f1c0a3f9813c3c3410e65976249a9095442bb37efb84d55a51a4af13e05a"},{"byte_length":3518,"kind":"tex","path":"modules/Production/Main.tex","sha256":"80c004efe4f1ad13364aa37b48f249fffe2f28cb879a380696c33c74ba29a176"}],"project":"production","selection":["Kernel","Main"],"semantic_id":"ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b","source_id":"c2fb286e33e6bdc8b415c6bbbc3afd824f9396d5ad9a0600b9bc282e7e4eb15c","spec":"lexlean/build-manifest/1"} +{"build_id":"5fd4bc9e06d1343a5339ed48b1fcd044f0b5d19fb87bb2e83c89e68922343e3d","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"8261568081d2bad38b880aefd91be774c419a0aa967629c5233bfcb3dcafef68"},{"byte_length":642,"kind":"project-config","path":"lexlean.toml","sha256":"6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e"},{"byte_length":1946,"kind":"source","path":"src/Kernel.lex.tex","sha256":"a437ec054ba361d174f27a15fdbec5579ed2c841212e7bc0ecc659cde626e1ec"},{"byte_length":1838,"kind":"source","path":"src/Main.lex.tex","sha256":"0aaa9bd2649c30feb852481dd9fe94d94c473ea275bef51eb9d92237ba111514"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Production.Kernel","module":"Kernel","source_path":"src/Kernel.lex.tex"},{"lean_module":"Production.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":9026,"kind":"coverage","path":"coverage/Production/Kernel.coverage.json","sha256":"3ea97485fa3e255128c0e407a5c9bb0e24b55a2ba50111da3ce3e49a884141bd"},{"byte_length":9294,"kind":"coverage","path":"coverage/Production/Main.coverage.json","sha256":"eeb4778546afa3d37c1910a3fa60ecac720f3c72cccd005161392751d7da275e"},{"byte_length":4700,"kind":"lean","path":"modules/Production/Kernel.lean","sha256":"fd63ab40fb52b7c19c13e75eeef1374c4193955b214637e3096fa168c90bd3a9"},{"byte_length":1180,"kind":"lean","path":"modules/Production/Main.lean","sha256":"0141c5543da183afef9d568f1b0f2715a232ded8c936b6ea03c42d3abd98156d"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Kernel.closure.json","sha256":"e35a3fc5cf572b5924dcc9c94be8e299ee6d0504a814b35600a6bf96b2318c47"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":3900,"kind":"map","path":"maps/Production/Kernel.map.json","sha256":"308e250c119458d414382703cffe0563d0df459a5844b741f178295e55adcf30"},{"byte_length":3571,"kind":"map","path":"maps/Production/Main.map.json","sha256":"671991284e5ebaad648b7a9aa44fedc0a5480942df7d13d54b086b8bf640142e"},{"byte_length":12235,"kind":"production-eligibility","path":"production/Production/Main.eligibility.json","sha256":"6c8ff35c840c08182f22729f284b07382ddce7f037e4aa40f3319c2fb61e5867"},{"byte_length":3394,"kind":"tex","path":"modules/Production/Kernel.tex","sha256":"d415f1c0a3f9813c3c3410e65976249a9095442bb37efb84d55a51a4af13e05a"},{"byte_length":3518,"kind":"tex","path":"modules/Production/Main.tex","sha256":"80c004efe4f1ad13364aa37b48f249fffe2f28cb879a380696c33c74ba29a176"}],"project":"production","selection":["Kernel","Main"],"semantic_id":"f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8","source_id":"d250fe6d3584d18e0a53f49ac172457540c88e60a54328beade0efb1bc001a8b","spec":"lexlean/build-manifest/1"} diff --git a/examples/production/expected/build/maps/Production/Kernel.map.json b/examples/production/expected/build/maps/Production/Kernel.map.json index cf7e60f61..a408fe2a8 100644 --- a/examples/production/expected/build/maps/Production/Kernel.map.json +++ b/examples/production/expected/build/maps/Production/Kernel.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Production/Kernel.lean"},{"id":1,"kind":"tex","path":"modules/Production/Kernel.tex"}],"mappings":[{"artifact":0,"gen_end":272,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":0,"gen_end":357,"gen_start":272,"node":1,"role":"declaration","source":0,"src_end":270,"src_start":115},{"artifact":0,"gen_end":624,"gen_start":357,"node":2,"role":"declaration","source":0,"src_end":549,"src_start":272},{"artifact":0,"gen_end":730,"gen_start":624,"node":3,"role":"declaration","source":0,"src_end":711,"src_start":551},{"artifact":0,"gen_end":856,"gen_start":730,"node":4,"role":"declaration","source":0,"src_end":929,"src_start":713},{"artifact":0,"gen_end":1021,"gen_start":856,"node":5,"role":"declaration","source":0,"src_end":1158,"src_start":931},{"artifact":0,"gen_end":4104,"gen_start":1021,"node":6,"role":"declaration","source":0,"src_end":1389,"src_start":1160},{"artifact":0,"gen_end":4517,"gen_start":4104,"node":7,"role":"declaration","source":0,"src_end":1699,"src_start":1391},{"artifact":0,"gen_end":4595,"gen_start":4517,"node":8,"role":"declaration","source":0,"src_end":1787,"src_start":1701},{"artifact":0,"gen_end":4677,"gen_start":4595,"node":9,"role":"declaration","source":0,"src_end":1910,"src_start":1789},{"artifact":0,"gen_end":4700,"gen_start":4677,"node":0,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":1,"gen_end":329,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":270,"src_start":115},{"artifact":1,"gen_end":843,"gen_start":329,"node":12,"role":"declaration","source":0,"src_end":549,"src_start":272},{"artifact":1,"gen_end":1196,"gen_start":843,"node":13,"role":"declaration","source":0,"src_end":711,"src_start":551},{"artifact":1,"gen_end":1585,"gen_start":1196,"node":14,"role":"declaration","source":0,"src_end":929,"src_start":713},{"artifact":1,"gen_end":2032,"gen_start":1585,"node":15,"role":"declaration","source":0,"src_end":1158,"src_start":931},{"artifact":1,"gen_end":2374,"gen_start":2032,"node":16,"role":"declaration","source":0,"src_end":1389,"src_start":1160},{"artifact":1,"gen_end":2941,"gen_start":2374,"node":17,"role":"declaration","source":0,"src_end":1699,"src_start":1391},{"artifact":1,"gen_end":3190,"gen_start":2941,"node":18,"role":"declaration","source":0,"src_end":1787,"src_start":1701},{"artifact":1,"gen_end":3379,"gen_start":3190,"node":19,"role":"declaration","source":0,"src_end":1910,"src_start":1789},{"artifact":1,"gen_end":3394,"gen_start":3379,"node":10,"role":"declaration","source":0,"src_end":1946,"src_start":0}],"module":"Kernel","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b","source_id":"c2fb286e33e6bdc8b415c6bbbc3afd824f9396d5ad9a0600b9bc282e7e4eb15c","sources":[{"id":0,"kind":"file","path":"src/Kernel.lex.tex","sha256":"a437ec054ba361d174f27a15fdbec5579ed2c841212e7bc0ecc659cde626e1ec"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Production/Kernel.lean"},{"id":1,"kind":"tex","path":"modules/Production/Kernel.tex"}],"mappings":[{"artifact":0,"gen_end":272,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":0,"gen_end":357,"gen_start":272,"node":1,"role":"declaration","source":0,"src_end":270,"src_start":115},{"artifact":0,"gen_end":624,"gen_start":357,"node":2,"role":"declaration","source":0,"src_end":549,"src_start":272},{"artifact":0,"gen_end":730,"gen_start":624,"node":3,"role":"declaration","source":0,"src_end":711,"src_start":551},{"artifact":0,"gen_end":856,"gen_start":730,"node":4,"role":"declaration","source":0,"src_end":929,"src_start":713},{"artifact":0,"gen_end":1021,"gen_start":856,"node":5,"role":"declaration","source":0,"src_end":1158,"src_start":931},{"artifact":0,"gen_end":4104,"gen_start":1021,"node":6,"role":"declaration","source":0,"src_end":1389,"src_start":1160},{"artifact":0,"gen_end":4517,"gen_start":4104,"node":7,"role":"declaration","source":0,"src_end":1699,"src_start":1391},{"artifact":0,"gen_end":4595,"gen_start":4517,"node":8,"role":"declaration","source":0,"src_end":1787,"src_start":1701},{"artifact":0,"gen_end":4677,"gen_start":4595,"node":9,"role":"declaration","source":0,"src_end":1910,"src_start":1789},{"artifact":0,"gen_end":4700,"gen_start":4677,"node":0,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":10,"role":"declaration","source":0,"src_end":1946,"src_start":0},{"artifact":1,"gen_end":329,"gen_start":134,"node":11,"role":"declaration","source":0,"src_end":270,"src_start":115},{"artifact":1,"gen_end":843,"gen_start":329,"node":12,"role":"declaration","source":0,"src_end":549,"src_start":272},{"artifact":1,"gen_end":1196,"gen_start":843,"node":13,"role":"declaration","source":0,"src_end":711,"src_start":551},{"artifact":1,"gen_end":1585,"gen_start":1196,"node":14,"role":"declaration","source":0,"src_end":929,"src_start":713},{"artifact":1,"gen_end":2032,"gen_start":1585,"node":15,"role":"declaration","source":0,"src_end":1158,"src_start":931},{"artifact":1,"gen_end":2374,"gen_start":2032,"node":16,"role":"declaration","source":0,"src_end":1389,"src_start":1160},{"artifact":1,"gen_end":2941,"gen_start":2374,"node":17,"role":"declaration","source":0,"src_end":1699,"src_start":1391},{"artifact":1,"gen_end":3190,"gen_start":2941,"node":18,"role":"declaration","source":0,"src_end":1787,"src_start":1701},{"artifact":1,"gen_end":3379,"gen_start":3190,"node":19,"role":"declaration","source":0,"src_end":1910,"src_start":1789},{"artifact":1,"gen_end":3394,"gen_start":3379,"node":10,"role":"declaration","source":0,"src_end":1946,"src_start":0}],"module":"Kernel","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-latex-module"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"}],"semantic_id":"f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8","source_id":"d250fe6d3584d18e0a53f49ac172457540c88e60a54328beade0efb1bc001a8b","sources":[{"id":0,"kind":"file","path":"src/Kernel.lex.tex","sha256":"a437ec054ba361d174f27a15fdbec5579ed2c841212e7bc0ecc659cde626e1ec"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production/expected/build/maps/Production/Main.map.json b/examples/production/expected/build/maps/Production/Main.map.json index dd86f7131..6d7d1884f 100644 --- a/examples/production/expected/build/maps/Production/Main.map.json +++ b/examples/production/expected/build/maps/Production/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Production/Main.lean"},{"id":1,"kind":"tex","path":"modules/Production/Main.tex"}],"mappings":[{"artifact":0,"gen_end":268,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":0,"gen_end":416,"gen_start":268,"node":1,"role":"declaration","source":0,"src_end":412,"src_start":135},{"artifact":0,"gen_end":562,"gen_start":416,"node":2,"role":"declaration","source":0,"src_end":660,"src_start":414},{"artifact":0,"gen_end":698,"gen_start":562,"node":3,"role":"declaration","source":0,"src_end":904,"src_start":662},{"artifact":0,"gen_end":794,"gen_start":698,"node":4,"role":"declaration","source":0,"src_end":1152,"src_start":906},{"artifact":0,"gen_end":887,"gen_start":794,"node":5,"role":"declaration","source":0,"src_end":1367,"src_start":1154},{"artifact":0,"gen_end":992,"gen_start":887,"node":6,"role":"declaration","source":0,"src_end":1571,"src_start":1369},{"artifact":0,"gen_end":1062,"gen_start":992,"node":7,"role":"declaration","source":0,"src_end":1669,"src_start":1573},{"artifact":0,"gen_end":1159,"gen_start":1062,"node":8,"role":"declaration","source":0,"src_end":1802,"src_start":1671},{"artifact":0,"gen_end":1180,"gen_start":1159,"node":0,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":1,"gen_end":657,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":412,"src_start":135},{"artifact":1,"gen_end":1159,"gen_start":657,"node":11,"role":"declaration","source":0,"src_end":660,"src_start":414},{"artifact":1,"gen_end":1723,"gen_start":1159,"node":12,"role":"declaration","source":0,"src_end":904,"src_start":662},{"artifact":1,"gen_end":2209,"gen_start":1723,"node":13,"role":"declaration","source":0,"src_end":1152,"src_start":906},{"artifact":1,"gen_end":2670,"gen_start":2209,"node":14,"role":"declaration","source":0,"src_end":1367,"src_start":1154},{"artifact":1,"gen_end":3122,"gen_start":2670,"node":15,"role":"declaration","source":0,"src_end":1571,"src_start":1369},{"artifact":1,"gen_end":3299,"gen_start":3122,"node":16,"role":"declaration","source":0,"src_end":1669,"src_start":1573},{"artifact":1,"gen_end":3503,"gen_start":3299,"node":17,"role":"declaration","source":0,"src_end":1802,"src_start":1671},{"artifact":1,"gen_end":3518,"gen_start":3503,"node":9,"role":"declaration","source":0,"src_end":1838,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b","source_id":"c2fb286e33e6bdc8b415c6bbbc3afd824f9396d5ad9a0600b9bc282e7e4eb15c","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"0aaa9bd2649c30feb852481dd9fe94d94c473ea275bef51eb9d92237ba111514"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Production/Main.lean"},{"id":1,"kind":"tex","path":"modules/Production/Main.tex"}],"mappings":[{"artifact":0,"gen_end":268,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":0,"gen_end":416,"gen_start":268,"node":1,"role":"declaration","source":0,"src_end":412,"src_start":135},{"artifact":0,"gen_end":562,"gen_start":416,"node":2,"role":"declaration","source":0,"src_end":660,"src_start":414},{"artifact":0,"gen_end":698,"gen_start":562,"node":3,"role":"declaration","source":0,"src_end":904,"src_start":662},{"artifact":0,"gen_end":794,"gen_start":698,"node":4,"role":"declaration","source":0,"src_end":1152,"src_start":906},{"artifact":0,"gen_end":887,"gen_start":794,"node":5,"role":"declaration","source":0,"src_end":1367,"src_start":1154},{"artifact":0,"gen_end":992,"gen_start":887,"node":6,"role":"declaration","source":0,"src_end":1571,"src_start":1369},{"artifact":0,"gen_end":1062,"gen_start":992,"node":7,"role":"declaration","source":0,"src_end":1669,"src_start":1573},{"artifact":0,"gen_end":1159,"gen_start":1062,"node":8,"role":"declaration","source":0,"src_end":1802,"src_start":1671},{"artifact":0,"gen_end":1180,"gen_start":1159,"node":0,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":1838,"src_start":0},{"artifact":1,"gen_end":657,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":412,"src_start":135},{"artifact":1,"gen_end":1159,"gen_start":657,"node":11,"role":"declaration","source":0,"src_end":660,"src_start":414},{"artifact":1,"gen_end":1723,"gen_start":1159,"node":12,"role":"declaration","source":0,"src_end":904,"src_start":662},{"artifact":1,"gen_end":2209,"gen_start":1723,"node":13,"role":"declaration","source":0,"src_end":1152,"src_start":906},{"artifact":1,"gen_end":2670,"gen_start":2209,"node":14,"role":"declaration","source":0,"src_end":1367,"src_start":1154},{"artifact":1,"gen_end":3122,"gen_start":2670,"node":15,"role":"declaration","source":0,"src_end":1571,"src_start":1369},{"artifact":1,"gen_end":3299,"gen_start":3122,"node":16,"role":"declaration","source":0,"src_end":1669,"src_start":1573},{"artifact":1,"gen_end":3503,"gen_start":3299,"node":17,"role":"declaration","source":0,"src_end":1802,"src_start":1671},{"artifact":1,"gen_end":3518,"gen_start":3503,"node":9,"role":"declaration","source":0,"src_end":1838,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8","source_id":"d250fe6d3584d18e0a53f49ac172457540c88e60a54328beade0efb1bc001a8b","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"0aaa9bd2649c30feb852481dd9fe94d94c473ea275bef51eb9d92237ba111514"}],"spec":"lexlean/source-map/1"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.process.json deleted file mode 100644 index e6ce2ee76..000000000 --- a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.process.json deleted file mode 100644 index 1b8c65852..000000000 --- a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.lean b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Collections.lean rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.lean diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.process.json new file mode 100644 index 000000000..203068a4e --- /dev/null +++ b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.lean b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Laws.lean rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.process.json similarity index 96% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.process.json rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.process.json index 400aaf7b4..a4937b49e 100644 --- a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.process.json +++ b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.lean b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.LexLeanRuntime.Portable.lean rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.lean diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.process.json new file mode 100644 index 000000000..0f1a4e08f --- /dev/null +++ b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.lean b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.lean similarity index 100% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.lean rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.lean diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.process.json similarity index 74% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.process.json rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.process.json index edc99ed3d..563797ebb 100644 --- a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.process.json +++ b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Kernel","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Production.Kernel.Shape' does not depend on any axioms\n'Production.Kernel.applyTwice' does not depend on any axioms\n'Production.Kernel.area' does not depend on any axioms\n'Production.Kernel.area_square' does not depend on any axioms\n'Production.Kernel.countdown' depends on axioms: [propext, Quot.sound]\n'Production.Kernel.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Production.Kernel.firstOr' does not depend on any axioms\n'Production.Kernel.positive' does not depend on any axioms\n'Production.Kernel.total' does not depend on any axioms\n","stdout_sha256":"e7872f440e4a20755a5548c3999faa8297516295868ef0be032f4dff66e551ca","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Kernel","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Production.Kernel.Shape' does not depend on any axioms\n'Production.Kernel.applyTwice' does not depend on any axioms\n'Production.Kernel.area' does not depend on any axioms\n'Production.Kernel.area_square' does not depend on any axioms\n'Production.Kernel.countdown' depends on axioms: [propext, Quot.sound]\n'Production.Kernel.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Production.Kernel.firstOr' does not depend on any axioms\n'Production.Kernel.positive' does not depend on any axioms\n'Production.Kernel.total' does not depend on any axioms\n","stdout_sha256":"e7872f440e4a20755a5548c3999faa8297516295868ef0be032f4dff66e551ca","tool":"lean"} diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.lean b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.lean similarity index 100% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.lean rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.lean diff --git a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.process.json b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.process.json similarity index 72% rename from examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.process.json rename to examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.process.json index 254cc8ed7..411f637bb 100644 --- a/examples/production/expected/verify/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.process.json +++ b/examples/production/expected/verify/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aecf58505f4e2844618eff0bdc9a2ce9d.Production.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Production.Main.checkedSum' depends on axioms: [propext, Quot.sound]\n'Production.Main.halvings' depends on axioms: [propext, Quot.sound]\n'Production.Main.headOr' does not depend on any axioms\n'Production.Main.quadruple' does not depend on any axioms\n'Production.Main.quadruple_three' does not depend on any axioms\n'Production.Main.shapeArea' does not depend on any axioms\n'Production.Main.sumAll' does not depend on any axioms\n'Production.Main.sum_three' does not depend on any axioms\n","stdout_sha256":"ecef933d7d628ddb695b86ecad94d180c8c2ce3a0bd988fe1d6bedb4e601987f","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af5a58e441acc8b93ded11826c51cc7c8.Production.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Production.Main.checkedSum' depends on axioms: [propext, Quot.sound]\n'Production.Main.halvings' depends on axioms: [propext, Quot.sound]\n'Production.Main.headOr' does not depend on any axioms\n'Production.Main.quadruple' does not depend on any axioms\n'Production.Main.quadruple_three' does not depend on any axioms\n'Production.Main.shapeArea' does not depend on any axioms\n'Production.Main.sumAll' does not depend on any axioms\n'Production.Main.sum_three' does not depend on any axioms\n","stdout_sha256":"ecef933d7d628ddb695b86ecad94d180c8c2ce3a0bd988fe1d6bedb4e601987f","tool":"lean"} diff --git a/examples/production/expected/verify/extract/LexLeanExtract.Xecf58505f4e2844618eff0bdc9a2ce9d.lean b/examples/production/expected/verify/extract/LexLeanExtract.Xf5a58e441acc8b93ded11826c51cc7c8.lean similarity index 100% rename from examples/production/expected/verify/extract/LexLeanExtract.Xecf58505f4e2844618eff0bdc9a2ce9d.lean rename to examples/production/expected/verify/extract/LexLeanExtract.Xf5a58e441acc8b93ded11826c51cc7c8.lean diff --git a/examples/production/expected/verify/extract/process.json b/examples/production/expected/verify/extract/process.json index 9e9477c04..b328fa696 100644 --- a/examples/production/expected/verify/extract/process.json +++ b/examples/production/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xecf58505f4e2844618eff0bdc9a2ce9d.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xecf58505f4e2844618eff0bdc9a2ce9d","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Production.Main.checkedSum\",\"Production.Main.shapeArea\",\"Production.Main.quadruple\",\"Production.Main.halvings\",\"Production.Main.sumAll\",\"Production.Main.headOr\"],\"constants\":[{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.checkedAdd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHAdd\",\"HAdd.hAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instAdd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"Option\",\"instHAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4294967295\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape\",\"kind\":\"inductive\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Production.Kernel.Shape.circle\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]}}},{\"name\":\"Production.Kernel.Shape.rectangle\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]}}}}]}},{\"name\":\"Production.Kernel.applyTwice\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\"]},\"inductive\":null},{\"name\":\"Production.Kernel.area\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Production.Kernel.Shape\",\"Production.Kernel.area.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Production.Kernel.Shape\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.30\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Production.Kernel.Shape.circle\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}},{\"kind\":\"constructor\",\"constructor\":\"Production.Kernel.Shape.rectangle\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Mul\",\"Nat\",\"OfNat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rectangle\"]},\"inductive\":null},{\"name\":\"Production.Kernel.countdown\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PSigma.mk\",\"Production.Kernel.countdown._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Production.Kernel.countdown\"]},\"inductive\":null},{\"name\":\"Production.Kernel.countdown_decreases\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._proof_1_32\",\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.firstOr\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"Production.Kernel.firstOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false},{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}]}}}}}},\"uses\":[\"List\",\"PUnit\",\"List.cons\",\"List.nil\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Production.Kernel.total\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"List.brecOn\",\"Production.Kernel.total._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.total\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Production.Kernel.total\"]},\"inductive\":null},{\"name\":\"Production.Main.checkedSum\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.instFixedUInt32\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.instFixedUInt32\"]},\"inductive\":null},{\"name\":\"Production.Main.halvings\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Production.Kernel.countdown\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Production.Kernel.countdown\"]},\"inductive\":null},{\"name\":\"Production.Main.headOr\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Production.Kernel.firstOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.firstOr\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Production.Kernel.firstOr\"]},\"inductive\":null},{\"name\":\"Production.Main.quadruple\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Production.Kernel.applyTwice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.applyTwice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Production.Kernel.applyTwice\"]},\"inductive\":null},{\"name\":\"Production.Main.shapeArea\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.area\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape.rectangle\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}},\"uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.area\",\"Production.Kernel.Shape.rectangle\"]},\"inductive\":null},{\"name\":\"Production.Main.sumAll\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Production.Kernel.total\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.total\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Nat\",\"Production.Kernel.total\"]},\"inductive\":null},{\"name\":\"Production.Kernel.Shape.casesOn\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rec\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.circle\",\"kind\":\"constructor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.rec\",\"kind\":\"recursor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.rectangle\",\"kind\":\"constructor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.area.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.casesOn\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown._unary\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"WellFounded.Nat.fix\",\"Production.Kernel.countdown.match_1\",\"Production.Kernel.countdown._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Eq.refl\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.firstOr.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.total._f\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.below\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Production.Kernel.total.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.total.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"Production.Kernel.countdown_decreases\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instAdd\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"UInt32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"11f2b986da02936d686ec942597cc5e399980e686510eed491fe44180e9751e0","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xf5a58e441acc8b93ded11826c51cc7c8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xf5a58e441acc8b93ded11826c51cc7c8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Production.Main.checkedSum\",\"Production.Main.shapeArea\",\"Production.Main.quadruple\",\"Production.Main.halvings\",\"Production.Main.sumAll\",\"Production.Main.headOr\"],\"constants\":[{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.checkedAdd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHAdd\",\"HAdd.hAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instAdd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Int\",\"Option\",\"instHAdd\",\"Int.instAdd\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt32\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4294967295\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.complement\",\"UInt32.land\",\"UInt32.lor\",\"UInt32.ofInt\",\"UInt32.shiftLeft\",\"UInt32.shiftRight\",\"UInt32.toNat\",\"UInt32.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape\",\"kind\":\"inductive\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Production.Kernel.Shape.circle\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]}}},{\"name\":\"Production.Kernel.Shape.rectangle\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]}}}}]}},{\"name\":\"Production.Kernel.applyTwice\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\"]},\"inductive\":null},{\"name\":\"Production.Kernel.area\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Production.Kernel.Shape\",\"Production.Kernel.area.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Production.Kernel.Shape\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.30\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Production.Kernel.Shape.circle\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}},{\"kind\":\"constructor\",\"constructor\":\"Production.Kernel.Shape.rectangle\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Mul\",\"Nat\",\"OfNat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanRuntime.multiply\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rectangle\"]},\"inductive\":null},{\"name\":\"Production.Kernel.countdown\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"PSigma.mk\",\"Production.Kernel.countdown._unary\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}]}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"erased\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Production.Kernel.countdown\"]},\"inductive\":null},{\"name\":\"Production.Kernel.countdown_decreases\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Not\",\"congrArg\",\"id\",\"instHSub\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.byContradiction\",\"Eq.mp\",\"Eq.trans\",\"HSub.hSub\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Nat.blt_eq\",\"Nat.decLt\",\"OfNat.ofNat\",\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._proof_1_32\",\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._simp_1_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.firstOr\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"Production.Kernel.firstOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false},{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false},{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"borrow\":false},{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}]}}}}}},\"uses\":[\"List\",\"PUnit\",\"List.cons\",\"List.nil\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Production.Kernel.total\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"List.brecOn\",\"Production.Kernel.total._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.total\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Production.Kernel.total\"]},\"inductive\":null},{\"name\":\"Production.Main.checkedSum\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt32\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.instFixedUInt32\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt32\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedAdd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Option\",\"UInt32\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedAdd\",\"LexLeanRuntime.instFixedUInt32\"]},\"inductive\":null},{\"name\":\"Production.Main.halvings\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Production.Kernel.countdown\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.countdown\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Production.Kernel.countdown\"]},\"inductive\":null},{\"name\":\"Production.Main.headOr\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Production.Kernel.firstOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.firstOr\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Production.Kernel.firstOr\"]},\"inductive\":null},{\"name\":\"Production.Main.quadruple\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Production.Kernel.applyTwice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.applyTwice\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Production.Kernel.applyTwice\"]},\"inductive\":null},{\"name\":\"Production.Main.shapeArea\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.area\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.Shape.rectangle\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.area\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}},\"uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.area\",\"Production.Kernel.Shape.rectangle\"]},\"inductive\":null},{\"name\":\"Production.Main.sumAll\",\"kind\":\"definition\",\"module\":\"Production.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Production.Kernel.total\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Production.Kernel.total\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Nat\",\"Production.Kernel.total\"]},\"inductive\":null},{\"name\":\"Production.Kernel.Shape.casesOn\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rec\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.circle\",\"kind\":\"constructor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.rec\",\"kind\":\"recursor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.Shape.rectangle\",\"kind\":\"constructor\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.area.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Production.Kernel.Shape\",\"Production.Kernel.Shape.casesOn\",\"Production.Kernel.Shape.circle\",\"Production.Kernel.Shape.rectangle\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown._unary\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"WellFounded.Nat.fix\",\"Production.Kernel.countdown.match_1\",\"Production.Kernel.countdown._unary._proof_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Eq.refl\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.firstOr.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.total._f\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"List.below\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Production.Kernel.total.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.total.match_1\",\"kind\":\"definition\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._proof_1_32\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"And\",\"Bool\",\"Eq\",\"False\",\"Int\",\"Nat\",\"Not\",\"id\",\"instDecidableEqBool\",\"instHAdd\",\"instHSub\",\"instLENat\",\"instLTNat\",\"instNatCastInt\",\"instOfNat\",\"instOfNatNat\",\"instSubNat\",\"le_of_le_of_eq\",\"of_decide_eq_true\",\"And.left\",\"And.right\",\"Bool.true\",\"Decidable.decide\",\"Eq.refl\",\"Eq.symm\",\"Eq.trans\",\"HAdd.hAdd\",\"HSub.hSub\",\"Int.add_one_le_of_lt\",\"Int.instAdd\",\"Int.instLEInt\",\"Int.instNegInt\",\"Int.instSub\",\"Int.sub_eq_zero_of_eq\",\"Int.sub_nonneg_of_le\",\"LE.le\",\"LT.lt\",\"List.cons\",\"List.nil\",\"Nat.cast\",\"Nat.le_of_not_lt\",\"Neg.neg\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Or.elim\",\"Lean.Omega.LinearCombo\",\"Lean.Omega.tidy_sat\",\"Lean.Omega.Coeffs.ofList\",\"Lean.Omega.Constraint.addEquality_sat\",\"Lean.Omega.Constraint.addInequality_sat\",\"Lean.Omega.Constraint.combine_sat'\",\"Lean.Omega.Constraint.isImpossible\",\"Lean.Omega.Constraint.mk\",\"Lean.Omega.Constraint.not_sat'_of_isImpossible\",\"Lean.Omega.Int.add_congr\",\"Lean.Omega.Int.ofNat_le_of_le\",\"Lean.Omega.Int.ofNat_lt_of_lt\",\"Lean.Omega.Int.ofNat_sub_dichotomy\",\"Lean.Omega.Int.sub_congr\",\"Lean.Omega.LinearCombo.add_eval\",\"Lean.Omega.LinearCombo.coordinate\",\"Lean.Omega.LinearCombo.coordinate_eval_0\",\"Lean.Omega.LinearCombo.coordinate_eval_1\",\"Lean.Omega.LinearCombo.eval\",\"Lean.Omega.LinearCombo.instAdd\",\"Lean.Omega.LinearCombo.instSub\",\"Lean.Omega.LinearCombo.mk\",\"Lean.Omega.LinearCombo.sub_eval\"],\"declaration\":null,\"inductive\":null},{\"name\":\"_private.Production.Kernel.0.Production.Kernel.countdown_decreases._simp_1_1\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"Not\",\"Bool.false\",\"Bool.not_eq_true\",\"Bool.true\",\"Eq.symm\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Production.Kernel.countdown._unary._proof_1\",\"kind\":\"theorem\",\"module\":\"Production.Kernel\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"theorem\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Eq\",\"InvImage\",\"Nat\",\"PSigma\",\"id\",\"instAddNat\",\"instHAdd\",\"instLTNat\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"HAdd.hAdd\",\"LT.lt\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"PSigma.casesOn\",\"PSigma.mk\",\"Production.Kernel.countdown_decreases\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instAdd\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"UInt32.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"11f2b986da02936d686ec942597cc5e399980e686510eed491fe44180e9751e0","tool":"lean"} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0.lean similarity index 95% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0.lean index 550964009..a3e72654f 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -31,4 +31,4 @@ def denote (left : UInt32) (right : UInt32) : _root_.LexLeanPreservation.Obs := theorem root (left : UInt32) (right : UInt32) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.u32 left), (_root_.LexLeanTarget.TargetSyntax.Value.u32 right)] (_root_.LexLeanPreservation.Rel (__fits_0 left right) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u32) (Production.Main.checkedSum left right))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 left right) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustCore.lex.tex similarity index 94% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustCore.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustCore.lex.tex index e3804e0b4..ecfb8b4b4 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustCore.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root : @920 := @921 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root : @920 := @921 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.flags @3 := UInt32 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.u32 @@ -83,7 +83,7 @@ @100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 @105 := List.getD.{0} @85 @87 @75 @100 @109 := fun (__e_n : @65) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.root @19 @75 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.root @19 @75 @110 := LexLeanPreservation.Rust.WTL @118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 @120 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,13 +194,13 @@ @321 := @316 @278 @322 := @135 @64 @323 := @322 @312 -@324 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.denote +@324 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.denote @326 := @324 @4 @17 -@327 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.__fits_0 +@327 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.__fits_0 @329 := @327 @4 @17 @332 := Production.Main.checkedSum @4 @17 @336 := LexLeanPreservation.encOption @3 @5 @332 -@339 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.root @4 @17 +@339 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.root @4 @17 @340 := Bool @341 := Ne.{1} @342 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustStd.lex.tex similarity index 94% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustStd.lex.tex index 4bb48e496..75d8ef843 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.root : @920 := @921 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.root : @920 := @921 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.flags @3 := UInt32 @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.u32 @@ -83,7 +83,7 @@ @100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 @105 := List.getD.{0} @85 @87 @75 @100 @109 := fun (__e_n : @65) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.root @19 @75 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.root @19 @75 @110 := LexLeanPreservation.Rust.WTL @118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 @120 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,13 +194,13 @@ @321 := @316 @278 @322 := @135 @64 @323 := @322 @312 -@324 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.denote +@324 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.denote @326 := @324 @4 @17 -@327 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.__fits_0 +@327 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.__fits_0 @329 := @327 @4 @17 @332 := Production.Main.checkedSum @4 @17 @336 := LexLeanPreservation.encOption @3 @5 @332 -@339 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.root @4 @17 +@339 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.root @4 @17 @340 := Bool @341 := Ne.{1} @342 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustCore.lean similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustCore.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustCore.lean index 1b19d944a..8765b1c5c 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustCore.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustStd.lean similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustStd.lean index 13ee01c68..e228ececd 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1.lean similarity index 98% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1.lean index 09a56b507..474df43f2 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat], [.nat, .nat]] }], functions := [ @@ -44,4 +44,4 @@ def denote (width : Nat) (height : Nat) : _root_.LexLeanPreservation.Obs := theorem root (width : Nat) (height : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat width), (_root_.LexLeanTarget.TargetSyntax.Value.nat height)] (_root_.LexLeanPreservation.Rel (__fits_0 width height) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Production.Main.shapeArea width height))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 width height) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustCore.lex.tex similarity index 94% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustCore.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustCore.lex.tex index 9dcf62edb..1ce90c927 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustCore.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustCore.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.__wt_0 : @16 := @453 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.root : @1128 := @1129 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.root : @1128 := @1129 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.flags @3 := Production.Kernel.Shape @4 := #0 -@6 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.__enc_0 @4 +@6 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -280,7 +280,7 @@ @485 := LexLeanTarget.TargetSyntax.Function.mk @475 @65 @476 @480 @490 := List.getD.{0} @472 @474 @9 @485 @494 := fun (__e_n : @24) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.root @4 @9 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.root @4 @9 @495 := @379 @61 @496 := @204 @61 @501 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @496 @207 @@ -302,12 +302,12 @@ @536 := @528 @68 @539 := (h : @202) -> (hs : @229) -> @388 @365 @541 := @536 @454 @507 -@542 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.denote +@542 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.denote @544 := @542 @27 @29 -@545 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.__fits_0 +@545 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.__fits_0 @547 := @545 @27 @29 @551 := @18 (Production.Main.shapeArea @27 @29) -@554 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.root @27 @29 +@554 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.root @27 @29 @555 := Bool @556 := Ne.{1} @557 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustStd.lex.tex similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustStd.lex.tex index fc899b5ef..7afce1b81 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustStd.lex.tex @@ -1,33 +1,33 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.__wt_0 : @16 := @453 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.root : @1128 := @1129 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.root : @1128 := @1129 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.flags @3 := Production.Kernel.Shape @4 := #0 -@6 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.__enc_0 @4 +@6 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.__enc_0 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @9 := 0 @@ -279,7 +279,7 @@ @480 := LexLeanTarget.TargetSyntax.Expr.value @476 @477 @485 := LexLeanTarget.TargetSyntax.Function.mk @475 @65 @476 @480 @490 := List.getD.{0} @472 @474 @9 @485 -@494 := fun (__e_n : @24) => LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.root @4 @9 +@494 := fun (__e_n : @24) => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.root @4 @9 @495 := @379 @61 @496 := @204 @61 @501 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @496 @207 @@ -301,12 +301,12 @@ @536 := @528 @68 @539 := (h : @202) -> (hs : @229) -> @388 @365 @541 := @536 @454 @507 -@542 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.denote +@542 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.denote @544 := @542 @27 @29 -@545 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.__fits_0 +@545 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.__fits_0 @547 := @545 @27 @29 @551 := @18 (Production.Main.shapeArea @27 @29) -@554 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.root @27 @29 +@554 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.root @27 @29 @555 := Bool @556 := Ne.{1} @557 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustCore.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustCore.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustCore.lean index a3a266065..d9d7790e8 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustCore.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -39,4 +39,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustStd.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustStd.lean index 14ef6ec68..d203b83eb 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -39,4 +39,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2.lean index c578ae9af..c7fd31434 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -48,4 +48,4 @@ def denote (value : Nat) : _root_.LexLeanPreservation.Obs := theorem root (value : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat value)] (_root_.LexLeanPreservation.Rel (__fits_0 value) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Production.Main.quadruple value))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 value) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustCore.lex.tex similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustCore.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustCore.lex.tex index 48b970872..252704e89 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustCore.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.root : @825 := @826 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.root @17 @60 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,12 +158,12 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.denote +@271 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.__fits_0 +@273 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.__fits_0 @274 := @273 @4 @277 := @5 (Production.Main.quadruple @4) -@279 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.root @4 +@279 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.root @4 @280 := Bool @281 := Ne.{1} @282 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustStd.lex.tex similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustStd.lex.tex index 16fc7d2fb..ce8233ade 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.root : @825 := @826 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -70,7 +70,7 @@ @81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 -@95 := fun (__e_n : @3) => LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.root @17 @60 +@95 := fun (__e_n : @3) => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -157,12 +157,12 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.denote +@271 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.__fits_0 +@273 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.__fits_0 @274 := @273 @4 @277 := @5 (Production.Main.quadruple @4) -@279 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.root @4 +@279 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.root @4 @280 := Bool @281 := Ne.{1} @282 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustCore.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustCore.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustCore.lean index 91056f24d..57999600e 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustCore.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -48,4 +48,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustStd.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustStd.lean index eafac40bc..21c15fc44 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -48,4 +48,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3.lean index 6ce76ac74..208516fdb 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -45,4 +45,4 @@ def denote (number : Nat) : _root_.LexLeanPreservation.Obs := theorem root (number : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat number)] (_root_.LexLeanPreservation.Rel (__fits_0 number) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Production.Main.halvings number))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 number) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustCore.lex.tex similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustCore.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustCore.lex.tex index 5e59e29a7..8bcef617e 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustCore.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustCore.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.root : @825 := @826 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -71,7 +71,7 @@ @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 @95 := fun (__e_n : @3) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.root @17 @60 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -158,12 +158,12 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.denote +@271 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.__fits_0 +@273 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.__fits_0 @274 := @273 @4 @277 := @5 (Production.Main.halvings @4) -@279 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.root @4 +@279 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.root @4 @280 := Bool @281 := Ne.{1} @282 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustStd.lex.tex similarity index 93% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustStd.lex.tex index 90f548cce..54352a249 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.root : @825 := @826 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.flags @3 := Nat @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.nat @@ -70,7 +70,7 @@ @81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 @86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 @91 := List.getD.{0} @71 @73 @60 @86 -@95 := fun (__e_n : @3) => LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.root @17 @60 +@95 := fun (__e_n : @3) => LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.root @17 @60 @96 := LexLeanPreservation.Rust.WTL @104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 @106 := LexLeanPreservation.Rust.wtl_nil @0 @@ -157,12 +157,12 @@ @268 := @262 @120 @269 := @121 @56 @270 := @269 @258 -@271 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.denote +@271 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.denote @272 := @271 @4 -@273 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.__fits_0 +@273 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.__fits_0 @274 := @273 @4 @277 := @5 (Production.Main.halvings @4) -@279 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.root @4 +@279 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.root @4 @280 := Bool @281 := Ne.{1} @282 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustCore.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustCore.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustCore.lean index 503bc1f3a..09fff080c 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustCore.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -38,4 +38,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustStd.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustStd.lean index c78342686..cc8eaaa89 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -38,4 +38,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4.lean similarity index 96% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4.lean index e775440d4..14eabf1a6 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -42,4 +42,4 @@ def denote (values : (List Nat)) : _root_.LexLeanPreservation.Obs := theorem root (values : (List Nat)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] (_root_.LexLeanPreservation.Rel (__fits_0 values) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Production.Main.sumAll values))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 values) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/Compose/RustStd.lex.tex similarity index 94% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/Compose/RustStd.lex.tex index 416ef85a9..7bf1e4904 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.root : @923 := @924 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -124,7 +124,7 @@ @195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 @200 := List.getD.{0} @181 @183 @170 @195 @204 := fun (__e_n : @3) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.root @15 @170 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.root @15 @170 @205 := LexLeanPreservation.Rust.WTL @213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 @215 := LexLeanPreservation.Rust.wtl_nil @0 @@ -202,12 +202,12 @@ @366 := @360 @229 @367 := @230 @166 @368 := @367 @356 -@369 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.denote +@369 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.denote @370 := @369 @6 -@371 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.__fits_0 +@371 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.__fits_0 @372 := @371 @6 @375 := @7 (Production.Main.sumAll @6) -@377 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.root @6 +@377 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.root @6 @378 := Bool @379 := Ne.{1} @380 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/RustStd.lean similarity index 96% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/RustStd.lean index a24250e4b..5ff93fe30 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -38,4 +38,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5.lean similarity index 97% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5.lean index a6c8701ed..12a6c5174 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5 +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -40,4 +40,4 @@ def denote (values : (List Nat)) : _root_.LexLeanPreservation.Obs := theorem root (values : (List Nat)) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] (_root_.LexLeanPreservation.Rel (__fits_0 values) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Production.Main.headOr values))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 values) -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5 +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5 diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/Compose/RustStd.lex.tex similarity index 94% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/Compose/RustStd.lex.tex rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/Compose/RustStd.lex.tex index 4f21e3d41..34229d7f6 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/Compose/RustStd.lex.tex +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5, - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5, + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.root : @923 := @924 { - all: [LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.root], +theorem LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.program -@1 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.krate -@2 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.flags +@0 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.program +@1 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.krate +@2 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.flags @3 := Nat @4 := List.{0} @5 := @4 @3 @@ -124,7 +124,7 @@ @195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 @200 := List.getD.{0} @181 @183 @170 @195 @204 := fun (__e_n : @3) => - LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.root @15 @170 + LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.root @15 @170 @205 := LexLeanPreservation.Rust.WTL @213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 @215 := LexLeanPreservation.Rust.wtl_nil @0 @@ -202,12 +202,12 @@ @366 := @360 @229 @367 := @230 @166 @368 := @367 @356 -@369 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.denote +@369 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.denote @370 := @369 @6 -@371 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.__fits_0 +@371 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.__fits_0 @372 := @371 @6 @375 := @7 (Production.Main.headOr @6) -@377 := LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.root @6 +@377 := LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.root @6 @378 := Bool @379 := Ne.{1} @380 := LexLeanPreservation.Obs diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/RustStd.lean similarity index 96% rename from examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/RustStd.lean rename to examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/RustStd.lean index 057c1b152..4af917056 100644 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/RustStd.lean +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd +namespace LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -38,4 +38,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd +end LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd diff --git a/examples/production/expected/verify/preserve/audit.txt b/examples/production/expected/verify/preserve/audit.txt index ab2556964..2590bf742 100644 --- a/examples/production/expected/verify/preserve/audit.txt +++ b/examples/production/expected/verify/preserve/audit.txt @@ -7737,74 +7737,74 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/production/expected/verify/preserve/preservation.json b/examples/production/expected/verify/preserve/preservation.json index b1e18d153..91381972d 100644 --- a/examples/production/expected/verify/preserve/preservation.json +++ b/examples/production/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":13344,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore","sha256":"24129d37f0c77d64b4115e66d37ed32256673a55a44fa9cfd1e6a543e9bdcdea","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore","sha256":"13683baefae531981ebea8ad3a81060383b45974a2e4d923db43afaaa671c895","target":"rust-core","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":13335,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd","sha256":"48b6419c6ad0b4ba5abc87f48b2ea555a84db02379545bf6af78545630565ce4","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd","sha256":"46723f0b48797e58aba7952d87099123cff866974c33e5fc4bd441e4eca1a1c0","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"45c95f47d885217841b48001c7340dbe71a7104c8d7612978bfa1a4902fa986f","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.root"},{"byte_length":6583,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":16804,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore","sha256":"9108116741af0d8bcf422314a4900253d15f8a55d5faf880f5fd76966974a2a2","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore","sha256":"a86e0030be179ea98057f1f898f2d7487c1f58c5a3274f32ff6385765f8b0046","target":"rust-core","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":16791,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd","sha256":"770438f47f0bfa35459a1e079093e672268e380f0efb1e512761e5fe6f56cd6f","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd","sha256":"c9501ca9f37c3cd65b6c8739a57ac0a251173e39599860e37851dc06ba98af2f","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"3f9cfeee17967b3ac746424d7f46307e7150264c7254f68affb95b48e88cdf6d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.root"},{"byte_length":4724,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":12040,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore","sha256":"f9bf8bd9bcbd1afd90f1fe68074820ad6e740fe2f471c6b67c4bcdcd60026c5d","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore","sha256":"c04870f095f4f606fbfb6fb9f75183781a8541176adeecd03354fd411eb14b80","target":"rust-core","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":12029,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd","sha256":"ae7a8fc8d2f278b61c122d1f0adb58531bdeae5ab2534c174dde42a7df686854","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd","sha256":"943b8657452b5164eeee60853aab775ac2573d391ac0b09c3a2d38e7e21c9cc3","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"18c12987556392e2e59cdf552a5e0c0c7dde6773ea07c0828621f66cc9d5a4e3","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.root"},{"byte_length":5629,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":12041,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore","sha256":"c021afd2ce2cd097c75e383e46cdec3fae32ccf6eb959155c0c6a3a630f7127b","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore","sha256":"9cb84a401810269d4a9ca6d302e218378e50c5d2f863c6feaa7b1a4f66f0fd01","target":"rust-core","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":12030,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd","sha256":"64f765ae8c248c14e829ec187ca83e416aafdbb4de3a20b54dba7f14fcfb197e","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd","sha256":"552f936ec820f26a9ad94b21611dcc65b92ff39040af4eb096f9d5ea4d9d89dd","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"df92dc9f77be1123bd9a67521a0d11a4bf62179993f5fe37e444611419c1dcd2","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":13516,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd","sha256":"fe2f9b210b3b53bd286a300e1a33482fede565e29619916ede010d2034ed5076","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd","sha256":"ab0642e6f95fb34a3e56263b4628a32e3ebf9b5517daeb78d5c55ae4d936dbc1","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"3900ce9f6eaabf4fc8f464a7528a6dcc99d1ef27a001edb434182aa77898664f","targets":["rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd","sha256":"059e0d52ec8e27488dfd8ec395979964c5e7de37d011bae30f370d52693340bf","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd","sha256":"358591d3b791ea3da19091d0a45504b3f56e6dd836142a9abcde201006ffd85c","target":"rust-std","theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"0f1f8d4bdd2fe58a0c5bda0a13b89300f1133e02341c9a10f0b9dca0746ec76a","targets":["rust-std"],"theorem":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":13344,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore","sha256":"c4329046e58fc8991f5dc8011a306a8de1fc41e286c9e00c3437ea89906b1a5f","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore","sha256":"9f42f3c695bfc94f21a496308daf7cf09a30d4ff3a93ffb71afef26ffcaa3761","target":"rust-core","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":13335,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd","sha256":"14811b1c3bbb37d99ee9e49a08eec142ce249ebe06f7eb969296aa8402ab40c8","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd","sha256":"271c02930fc13541c13b9a5fe393bc0567bbcd84e5b1c1db0e0f25424da544a7","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"048299ccb2b891ee1e32d5b837ad8a4b06cdc734c82816373c9de5eab7b18d30","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.root"},{"byte_length":6583,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":16804,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore","sha256":"d973dc5ef63579c6bc8e6da477f2a13e6fd73e5503925d9886a7b9ff0b8482a6","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore","sha256":"83a599a5416442cdbf509aeaa58e39ded6df5cccfafe05f80760d0c0c9147fe9","target":"rust-core","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":16791,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd","sha256":"355965761f280e4e83517d08cb02779e8760e6050fff311851fa5b912e0e53d6","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd","sha256":"2da8fc10a612e72e7a8e79706e9f6b2598bc40fbd7c5227a36c0ff63e37ff556","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"723bdea3cf78873c857e761c96b990b74343e27326995a6571f5a0cb763d9228","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.root"},{"byte_length":4724,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":12040,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore","sha256":"08243fc9512a73c025f4b4daa1cac46c03d5ae445e7f939af7bec11dbdf6017a","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore","sha256":"d46ff903a7735fbf2cf7efb586eccd543042bab1f233e9aa9e8e97110066fba3","target":"rust-core","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":12029,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd","sha256":"0390c48a0729882baafe15ec0ad6452f6e7e15fb8f8d3de01d1f006ce20ab312","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd","sha256":"aa5a39707fbf78ca5fc82abf20ae9b390a85f096e1f477deafac125d7104a850","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"8dd3dccd47189bef94a24f791d365999ccaba27fd95b9bc048fba159e90280b5","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.root"},{"byte_length":5629,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":12041,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore","sha256":"7d8468df0119b0b1de97aba9dcaf8ae0a1df138b3262de094a53eea9119e2793","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore","sha256":"548bcee5e2aa593acb875823086c8aa0105b11cd9c7d98c2ae033f784c8ebbd8","target":"rust-core","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":12030,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd","sha256":"067394853b5eb5034ebdd41134ca83b70fcdb6ce63dcfa43d742ca6db6efe905","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd","sha256":"cbb07b75e5d2751bcbff4ff3899cc2cc3b184be7c3efbf3e9077572ef82dd7df","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"7ee839779603d04d86c948366c39438312a54a6bb271d86ebad1cd2e66e4c3dc","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":13516,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd","sha256":"4050e0ff694a47d3adf898c20766e8824202f3bb0834b78193cef77c99f2a3f3","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd","sha256":"b18e809c5b4b7ab28265dbde61352cc0a56e0bba3d338b16dc2bc44be7a3da71","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"72292e2a8ee0992e14145d6fac45f216b18a5736787308be2715a4e7ec6be0d6","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd","sha256":"44db8ee54fb06f61abe2dda28dcd071d9b69f3286a92c9112f99a0251b6c509e","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd","sha256":"e1f847b6a4e2dbe4a9b03bb7c4e3f0f80940ec2b82332e644202756d40aff3f3","target":"rust-std","theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"ba84212d7dc0c188b3edab3f0b63125dd00ecb805e61a176de5495adbb6a187a","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/production/expected/verify/probe/LexLeanProbe.Pecf58505f4e2844618eff0bdc9a2ce9d.lean b/examples/production/expected/verify/probe/LexLeanProbe.Pf5a58e441acc8b93ded11826c51cc7c8.lean similarity index 100% rename from examples/production/expected/verify/probe/LexLeanProbe.Pecf58505f4e2844618eff0bdc9a2ce9d.lean rename to examples/production/expected/verify/probe/LexLeanProbe.Pf5a58e441acc8b93ded11826c51cc7c8.lean diff --git a/examples/production/expected/verify/probe/process.json b/examples/production/expected/verify/probe/process.json index 303604c48..0f07077ae 100644 --- a/examples/production/expected/verify/probe/process.json +++ b/examples/production/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pecf58505f4e2844618eff0bdc9a2ce9d.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pecf58505f4e2844618eff0bdc9a2ce9d","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pf5a58e441acc8b93ded11826c51cc7c8.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pf5a58e441acc8b93ded11826c51cc7c8","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json deleted file mode 100644 index 6c778bd97..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json deleted file mode 100644 index 9f06302cf..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json deleted file mode 100644 index 5aa6800a7..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json deleted file mode 100644 index 835c498f2..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json deleted file mode 100644 index 40c01ff12..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json deleted file mode 100644 index 504484421..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json deleted file mode 100644 index 8bc2c07a3..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json deleted file mode 100644 index 52969aefe..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json deleted file mode 100644 index 450d05cf3..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json deleted file mode 100644 index 21f2da7a2..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json deleted file mode 100644 index 8209c3d65..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json deleted file mode 100644 index df6e12e79..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json deleted file mode 100644 index a62a4ba5b..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json deleted file mode 100644 index 90e5319b7..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json deleted file mode 100644 index 83ed46766..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json deleted file mode 100644 index cd7d0505e..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json deleted file mode 100644 index 962c5f94f..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json deleted file mode 100644 index ddc9e8d0d..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json deleted file mode 100644 index 69699282b..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json deleted file mode 100644 index e621aa12c..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json deleted file mode 100644 index 6b6b4fd96..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json deleted file mode 100644 index e9a50d393..000000000 --- a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json new file mode 100644 index 000000000..c03567884 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json new file mode 100644 index 000000000..9fa9dfd11 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json rename to examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json index 83f5070e9..325d26c76 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd.json +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R13.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json new file mode 100644 index 000000000..63b0e89d5 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json new file mode 100644 index 000000000..7718259ba --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json new file mode 100644 index 000000000..c4f2d91e5 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json new file mode 100644 index 000000000..bf05be0d6 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json rename to examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json index 05b0efb75..f7cf36219 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd.json +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R10.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json new file mode 100644 index 000000000..2b1a18956 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json new file mode 100644 index 000000000..5b9e3631f --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json new file mode 100644 index 000000000..f4f8bd3d0 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json new file mode 100644 index 000000000..30ac3a156 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json rename to examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json index 42c4b547c..7583d82d9 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd.json +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R11.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json new file mode 100644 index 000000000..6d8cceebb --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json new file mode 100644 index 000000000..7aa30ead5 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json new file mode 100644 index 000000000..8ca56da48 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json new file mode 100644 index 000000000..0cddc04f1 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json similarity index 57% rename from examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json rename to examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json index ae46d6843..3dd0d3967 100644 --- a/examples/production-coverage/expected/verify/process/leanchecker/LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd.json +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf3572b43e36d5c62b7601d32507ebc3a.R12.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json new file mode 100644 index 000000000..c575cc080 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json new file mode 100644 index 000000000..fb266d621 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json new file mode 100644 index 000000000..48688325b --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json new file mode 100644 index 000000000..1e559bd2b --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json new file mode 100644 index 000000000..97307a000 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json new file mode 100644 index 000000000..729235972 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json new file mode 100644 index 000000000..9628f86a3 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json new file mode 100644 index 000000000..b8ddf9738 --- /dev/null +++ b/examples/production/expected/verify/process/leanchecker/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json index d2f4b2ce9..29c7b3090 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"906145791431d036a18e82fbbd46a58f88c34d33acce3cf74dd8867e6ff3304a","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"531665fb0302a3e1e19130bebaedee468fe5a68411b480ca471fa52e02740620","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json deleted file mode 100644 index 1419685af..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json deleted file mode 100644 index cf7942fda..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json deleted file mode 100644 index 97b91a011..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json deleted file mode 100644 index 431bd6b7e..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json deleted file mode 100644 index f26b1a503..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json deleted file mode 100644 index 9193f1226..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json deleted file mode 100644 index 0b36d2d30..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json deleted file mode 100644 index 4245b01f6..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json deleted file mode 100644 index 2a821f24d..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json deleted file mode 100644 index 170f5d657..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json deleted file mode 100644 index 51f9c2121..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json deleted file mode 100644 index 27aded32d..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json deleted file mode 100644 index 62634c9d3..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json deleted file mode 100644 index 8c51398f1..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json deleted file mode 100644 index 036fa4863..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json deleted file mode 100644 index 5060f6ced..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json deleted file mode 100644 index bddd04c04..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json deleted file mode 100644 index 5b02bdd32..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json deleted file mode 100644 index e75678956..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json deleted file mode 100644 index c19b3079b..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json deleted file mode 100644 index bb463993d..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json deleted file mode 100644 index 6f449ec79..000000000 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json similarity index 57% rename from examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json rename to examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json index b59d30c81..5831b8981 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R0/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json new file mode 100644 index 000000000..a05765951 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json new file mode 100644 index 000000000..29d73931b --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json new file mode 100644 index 000000000..8128465a0 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json new file mode 100644 index 000000000..5cd048a38 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json similarity index 57% rename from examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json rename to examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json index 1db5c5c45..7db66255b 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R1/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json new file mode 100644 index 000000000..36b9dcc0f --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json new file mode 100644 index 000000000..00b687530 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json new file mode 100644 index 000000000..6c81eb302 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json new file mode 100644 index 000000000..4ba624706 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json similarity index 57% rename from examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json rename to examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json index 82c329bdc..adfd97d09 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R2/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json new file mode 100644 index 000000000..12ff097ab --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json new file mode 100644 index 000000000..d79aef39a --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json new file mode 100644 index 000000000..2424ed896 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json new file mode 100644 index 000000000..e0ef97042 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json similarity index 57% rename from examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json rename to examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json index 5603b6b9b..945d9cacd 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cecf58505f4e2844618eff0bdc9a2ce9d/R3/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R3.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json new file mode 100644 index 000000000..99297cfb6 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json new file mode 100644 index 000000000..b432f518d --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json new file mode 100644 index 000000000..0053c95fe --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json new file mode 100644 index 000000000..14446b9e5 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json new file mode 100644 index 000000000..7291de2e9 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json new file mode 100644 index 000000000..4283bc1c3 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json new file mode 100644 index 000000000..ddb88f73c --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json new file mode 100644 index 000000000..0333f3ebe --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json new file mode 100644 index 000000000..c0043d2b3 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json new file mode 100644 index 000000000..af9be5814 --- /dev/null +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Cf5a58e441acc8b93ded11826c51cc7c8/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/production/lexlean.lock b/examples/production/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/examples/production/lexlean.lock +++ b/examples/production/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/reasoning/expected/build/manifest.json b/examples/reasoning/expected/build/manifest.json index 0cb85b818..cf7aa018e 100644 --- a/examples/reasoning/expected/build/manifest.json +++ b/examples/reasoning/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"62e1c936c69007af9b7f98ca48a157c61f06c5ca99b580ff0990593215c0d6a3","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":3061,"kind":"lexicon","path":"glossary/reasoning.titles","sha256":"e47cc403ae3b7c1ac2f3fc574239f31c15973f248243a2e0b70c8000caf68f98"},{"byte_length":1945,"kind":"lock","path":"lexlean.lock","sha256":"69bcc64cbddb10f810b0455998c7d8d2b1dd95db9f18ad004293005aa198edd2"},{"byte_length":738,"kind":"project-config","path":"lexlean.toml","sha256":"254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf"},{"byte_length":4636,"kind":"source","path":"src/Budget.lex.tex","sha256":"107fc5d7f6acd256caf10ae6a53953c04a86dacfc953d16196805f2f71aa835f"},{"byte_length":27439,"kind":"source","path":"src/Clinic.lex.tex","sha256":"01d7ef34f88ff99c06d1bd95d1e580e88e2b75b2d2826bfce7462f6514d1d05a"},{"byte_length":30065,"kind":"source","path":"src/Main.lex.tex","sha256":"1c528893e116cb6b0cf1f39acb17a02c4e3e5302c5c8e2c802bb3cff19582468"},{"byte_length":8705,"kind":"source","path":"src/Planner.lex.tex","sha256":"8ebdbb36e0f5607e8ca0cdac698535bdd0fc793f9173ecc275817b706ec68f16"},{"byte_length":3642,"kind":"source","path":"src/Screening.lex.tex","sha256":"3dc86d2c1968e2eee6b3f55e1013f2ad4506f81a29a261e767d7dd2029b77efc"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Reasoning.Budget","module":"Budget","source_path":"src/Budget.lex.tex"},{"lean_module":"Reasoning.Clinic","module":"Clinic","source_path":"src/Clinic.lex.tex"},{"lean_module":"Reasoning.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Reasoning.Planner","module":"Planner","source_path":"src/Planner.lex.tex"},{"lean_module":"Reasoning.Screening","module":"Screening","source_path":"src/Screening.lex.tex"}],"outputs":[{"byte_length":12731,"kind":"coverage","path":"coverage/Reasoning/Budget.coverage.json","sha256":"d203ca71639c6070536b7c5cfacedd0381c29cbec7e00047f56e818c53d6ae29"},{"byte_length":23360,"kind":"coverage","path":"coverage/Reasoning/Clinic.coverage.json","sha256":"90bcf5385ba8615ee75cd0a7f168e017f9124f1f6cf7981009ca07e13f9779f6"},{"byte_length":29286,"kind":"coverage","path":"coverage/Reasoning/Main.coverage.json","sha256":"fb5ffec8c5eb5203df581c3788e5ad4ece2862592a53b5f5d626d18c2e841f2e"},{"byte_length":17423,"kind":"coverage","path":"coverage/Reasoning/Planner.coverage.json","sha256":"42e72aec84844766d6505e3b885feb0b07295a96c78b0f67d7cf071f7b71331d"},{"byte_length":12874,"kind":"coverage","path":"coverage/Reasoning/Screening.coverage.json","sha256":"f38daac390fb621e0a407f16cec5aad847dccbbfd8dd8eda8e8cb7e1ce42ebc7"},{"byte_length":59604,"kind":"lean","path":"modules/Reasoning/Budget.lean","sha256":"13cb23a1119fad06996a3bdbeee2ccb9060ecfb3dc7bbe88d04d6884d763a829"},{"byte_length":139655,"kind":"lean","path":"modules/Reasoning/Clinic.lean","sha256":"55966472a6d676e56b9c8ae1eb0f05b3b477a921075d1c7354c107398b8e2440"},{"byte_length":87124,"kind":"lean","path":"modules/Reasoning/Main.lean","sha256":"5b4a8724cca748ec75c20b0944481b9de79db99c727146896d0203d40d91ec94"},{"byte_length":158737,"kind":"lean","path":"modules/Reasoning/Planner.lean","sha256":"212bd7913e2880719d9b8fac3811db3ec8e0227b1a46d96e93fb9315262e8f7c"},{"byte_length":42547,"kind":"lean","path":"modules/Reasoning/Screening.lean","sha256":"060035b4fcf49df396af1c1a28a46af408e8d9c4f2b9b3935703d3a38c811a5f"},{"byte_length":11233,"kind":"lexicon-closure","path":"lexicons/Budget.closure.json","sha256":"cd5b9087dba571f9410cceb129c23f19613d232799a59279934f24f1c9c341e0"},{"byte_length":11233,"kind":"lexicon-closure","path":"lexicons/Clinic.closure.json","sha256":"e6bf53c5a76f0e7565a0e1a643a439d4e9e3e9e4571094fa75e4afb3dc11b6f7"},{"byte_length":11231,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"2a209ecbafc820ae30051979f00499bb931d3bbd13e27301326cf60baae0b982"},{"byte_length":11234,"kind":"lexicon-closure","path":"lexicons/Planner.closure.json","sha256":"5a53b13b649333892d981f1d8d11cb229147651c0087fa0d04d05a0300373732"},{"byte_length":11236,"kind":"lexicon-closure","path":"lexicons/Screening.closure.json","sha256":"538dbf529cb24abcec5c2f68b3abfaca608b7197a5f5125bd83c5eea370c73ae"},{"byte_length":6180,"kind":"map","path":"maps/Reasoning/Budget.map.json","sha256":"0b1ee654fe60946f0b728fb67c035a3cf6bdc6b3f2d50a55837d3871e75e24b8"},{"byte_length":19015,"kind":"map","path":"maps/Reasoning/Clinic.map.json","sha256":"a79f44aff7f79cd70d1777570dc59cb8f2cbc1523432014a6d5c5331597075f3"},{"byte_length":23346,"kind":"map","path":"maps/Reasoning/Main.map.json","sha256":"9f941267ce01e547b76ff5cde150a5ce2b0c30a7eaa7636357b4d4ecaaad382a"},{"byte_length":11733,"kind":"map","path":"maps/Reasoning/Planner.map.json","sha256":"7847a8d452608c53b7a33d4c3e6c2d5a099896feb2a95b045f780d0637a95d5e"},{"byte_length":6182,"kind":"map","path":"maps/Reasoning/Screening.map.json","sha256":"00c9ecffaf8469257c56b59c4d3e5588c25be9b861aea05fd21dd2cf9a2527af"},{"byte_length":216758,"kind":"production-eligibility","path":"production/Reasoning/Main.eligibility.json","sha256":"ac218965e553140b13bbaa660d46558f5a0040d9aa89c4d17f93bd02b4946413"},{"byte_length":34987,"kind":"tex","path":"modules/Reasoning/Budget.tex","sha256":"e119790e14fb08097a91884bd4d4576ecf25f73b8dfb77cb8a4a6974b9bd139c"},{"byte_length":78159,"kind":"tex","path":"modules/Reasoning/Clinic.tex","sha256":"9f22e4e59d2b2515287ca787c5bbef1669441372e69d090b8dbfbc4182088896"},{"byte_length":71965,"kind":"tex","path":"modules/Reasoning/Main.tex","sha256":"cf47f1f8008e33cf5a6a231b5dc3bc349446fd6ae48a9bc7570a8291a93f81fc"},{"byte_length":90367,"kind":"tex","path":"modules/Reasoning/Planner.tex","sha256":"1517be188348a5e8c29ecac93545fa4ac2338e802a7a030bfec7ccc6fb5317f1"},{"byte_length":27194,"kind":"tex","path":"modules/Reasoning/Screening.tex","sha256":"dd053d08d2811509a8659e75b228530b5bff859bb749a955297b965407bf13e4"}],"project":"reasoning","selection":["Budget","Clinic","Main","Planner","Screening"],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","spec":"lexlean/build-manifest/1"} +{"build_id":"e826a5099eef8fdf565817b4afc2347ed32d388f11daaba203bbd5323f083517","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":3061,"kind":"lexicon","path":"glossary/reasoning.titles","sha256":"e47cc403ae3b7c1ac2f3fc574239f31c15973f248243a2e0b70c8000caf68f98"},{"byte_length":1945,"kind":"lock","path":"lexlean.lock","sha256":"2f45b19e2736550e456990c7b4ff2c56f80e82cedaf61b927b858d52ab7d0f56"},{"byte_length":738,"kind":"project-config","path":"lexlean.toml","sha256":"254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf"},{"byte_length":4636,"kind":"source","path":"src/Budget.lex.tex","sha256":"107fc5d7f6acd256caf10ae6a53953c04a86dacfc953d16196805f2f71aa835f"},{"byte_length":27439,"kind":"source","path":"src/Clinic.lex.tex","sha256":"01d7ef34f88ff99c06d1bd95d1e580e88e2b75b2d2826bfce7462f6514d1d05a"},{"byte_length":30065,"kind":"source","path":"src/Main.lex.tex","sha256":"1c528893e116cb6b0cf1f39acb17a02c4e3e5302c5c8e2c802bb3cff19582468"},{"byte_length":8705,"kind":"source","path":"src/Planner.lex.tex","sha256":"8ebdbb36e0f5607e8ca0cdac698535bdd0fc793f9173ecc275817b706ec68f16"},{"byte_length":3642,"kind":"source","path":"src/Screening.lex.tex","sha256":"3dc86d2c1968e2eee6b3f55e1013f2ad4506f81a29a261e767d7dd2029b77efc"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Reasoning.Budget","module":"Budget","source_path":"src/Budget.lex.tex"},{"lean_module":"Reasoning.Clinic","module":"Clinic","source_path":"src/Clinic.lex.tex"},{"lean_module":"Reasoning.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Reasoning.Planner","module":"Planner","source_path":"src/Planner.lex.tex"},{"lean_module":"Reasoning.Screening","module":"Screening","source_path":"src/Screening.lex.tex"}],"outputs":[{"byte_length":12731,"kind":"coverage","path":"coverage/Reasoning/Budget.coverage.json","sha256":"d203ca71639c6070536b7c5cfacedd0381c29cbec7e00047f56e818c53d6ae29"},{"byte_length":23360,"kind":"coverage","path":"coverage/Reasoning/Clinic.coverage.json","sha256":"90bcf5385ba8615ee75cd0a7f168e017f9124f1f6cf7981009ca07e13f9779f6"},{"byte_length":29286,"kind":"coverage","path":"coverage/Reasoning/Main.coverage.json","sha256":"fb5ffec8c5eb5203df581c3788e5ad4ece2862592a53b5f5d626d18c2e841f2e"},{"byte_length":17423,"kind":"coverage","path":"coverage/Reasoning/Planner.coverage.json","sha256":"42e72aec84844766d6505e3b885feb0b07295a96c78b0f67d7cf071f7b71331d"},{"byte_length":12874,"kind":"coverage","path":"coverage/Reasoning/Screening.coverage.json","sha256":"f38daac390fb621e0a407f16cec5aad847dccbbfd8dd8eda8e8cb7e1ce42ebc7"},{"byte_length":59604,"kind":"lean","path":"modules/Reasoning/Budget.lean","sha256":"13cb23a1119fad06996a3bdbeee2ccb9060ecfb3dc7bbe88d04d6884d763a829"},{"byte_length":139655,"kind":"lean","path":"modules/Reasoning/Clinic.lean","sha256":"55966472a6d676e56b9c8ae1eb0f05b3b477a921075d1c7354c107398b8e2440"},{"byte_length":87124,"kind":"lean","path":"modules/Reasoning/Main.lean","sha256":"5b4a8724cca748ec75c20b0944481b9de79db99c727146896d0203d40d91ec94"},{"byte_length":158737,"kind":"lean","path":"modules/Reasoning/Planner.lean","sha256":"212bd7913e2880719d9b8fac3811db3ec8e0227b1a46d96e93fb9315262e8f7c"},{"byte_length":42547,"kind":"lean","path":"modules/Reasoning/Screening.lean","sha256":"060035b4fcf49df396af1c1a28a46af408e8d9c4f2b9b3935703d3a38c811a5f"},{"byte_length":11233,"kind":"lexicon-closure","path":"lexicons/Budget.closure.json","sha256":"cd5b9087dba571f9410cceb129c23f19613d232799a59279934f24f1c9c341e0"},{"byte_length":11233,"kind":"lexicon-closure","path":"lexicons/Clinic.closure.json","sha256":"e6bf53c5a76f0e7565a0e1a643a439d4e9e3e9e4571094fa75e4afb3dc11b6f7"},{"byte_length":11231,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"2a209ecbafc820ae30051979f00499bb931d3bbd13e27301326cf60baae0b982"},{"byte_length":11234,"kind":"lexicon-closure","path":"lexicons/Planner.closure.json","sha256":"5a53b13b649333892d981f1d8d11cb229147651c0087fa0d04d05a0300373732"},{"byte_length":11236,"kind":"lexicon-closure","path":"lexicons/Screening.closure.json","sha256":"538dbf529cb24abcec5c2f68b3abfaca608b7197a5f5125bd83c5eea370c73ae"},{"byte_length":6180,"kind":"map","path":"maps/Reasoning/Budget.map.json","sha256":"742d20d211275a78cad0204ec1fc7d07e4ab62c0d70fa0cacb02cd5bca72ad6f"},{"byte_length":19015,"kind":"map","path":"maps/Reasoning/Clinic.map.json","sha256":"f5c3a491aeb23ca252bbc8f9439d0d72debc40aeb155459918718eddfc0063bd"},{"byte_length":23346,"kind":"map","path":"maps/Reasoning/Main.map.json","sha256":"6e090eac0be7aa1ce4f205afbfb6df740e4b4331e08691238309454b4b5ff7ea"},{"byte_length":11733,"kind":"map","path":"maps/Reasoning/Planner.map.json","sha256":"d5a5227c6d6972aefaf75ec8022c7847e454d8e80f93a2d4ed03867ac04da980"},{"byte_length":6182,"kind":"map","path":"maps/Reasoning/Screening.map.json","sha256":"26b091c453a277c5dd73bd477b2cb9d15812dbe39af6fa71dfea2262edbd5e86"},{"byte_length":216758,"kind":"production-eligibility","path":"production/Reasoning/Main.eligibility.json","sha256":"ac218965e553140b13bbaa660d46558f5a0040d9aa89c4d17f93bd02b4946413"},{"byte_length":34987,"kind":"tex","path":"modules/Reasoning/Budget.tex","sha256":"e119790e14fb08097a91884bd4d4576ecf25f73b8dfb77cb8a4a6974b9bd139c"},{"byte_length":78159,"kind":"tex","path":"modules/Reasoning/Clinic.tex","sha256":"9f22e4e59d2b2515287ca787c5bbef1669441372e69d090b8dbfbc4182088896"},{"byte_length":71965,"kind":"tex","path":"modules/Reasoning/Main.tex","sha256":"cf47f1f8008e33cf5a6a231b5dc3bc349446fd6ae48a9bc7570a8291a93f81fc"},{"byte_length":90367,"kind":"tex","path":"modules/Reasoning/Planner.tex","sha256":"1517be188348a5e8c29ecac93545fa4ac2338e802a7a030bfec7ccc6fb5317f1"},{"byte_length":27194,"kind":"tex","path":"modules/Reasoning/Screening.tex","sha256":"dd053d08d2811509a8659e75b228530b5bff859bb749a955297b965407bf13e4"}],"project":"reasoning","selection":["Budget","Clinic","Main","Planner","Screening"],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","spec":"lexlean/build-manifest/1"} diff --git a/examples/reasoning/expected/build/maps/Reasoning/Budget.map.json b/examples/reasoning/expected/build/maps/Reasoning/Budget.map.json index 006ed4cc9..91bda3b3a 100644 --- a/examples/reasoning/expected/build/maps/Reasoning/Budget.map.json +++ b/examples/reasoning/expected/build/maps/Reasoning/Budget.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Budget.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Budget.tex"}],"mappings":[{"artifact":0,"gen_end":351,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":0,"gen_end":494,"gen_start":351,"node":1,"role":"declaration","source":0,"src_end":324,"src_start":145},{"artifact":0,"gen_end":575,"gen_start":494,"node":2,"role":"declaration","source":0,"src_end":448,"src_start":326},{"artifact":0,"gen_end":576,"gen_start":575,"node":3,"role":"declaration","source":0,"src_end":588,"src_start":450},{"artifact":0,"gen_end":3685,"gen_start":576,"node":4,"role":"declaration","source":0,"src_end":867,"src_start":590},{"artifact":0,"gen_end":6823,"gen_start":3685,"node":5,"role":"declaration","source":0,"src_end":1178,"src_start":869},{"artifact":0,"gen_end":8110,"gen_start":6823,"node":6,"role":"declaration","source":0,"src_end":1482,"src_start":1180},{"artifact":0,"gen_end":11252,"gen_start":8110,"node":7,"role":"declaration","source":0,"src_end":1785,"src_start":1484},{"artifact":0,"gen_end":14423,"gen_start":11252,"node":8,"role":"declaration","source":0,"src_end":2120,"src_start":1787},{"artifact":0,"gen_end":15943,"gen_start":14423,"node":9,"role":"declaration","source":0,"src_end":2513,"src_start":2122},{"artifact":0,"gen_end":16030,"gen_start":15943,"node":10,"role":"declaration","source":0,"src_end":2632,"src_start":2515},{"artifact":0,"gen_end":16121,"gen_start":16030,"node":11,"role":"declaration","source":0,"src_end":2777,"src_start":2634},{"artifact":0,"gen_end":19188,"gen_start":16121,"node":12,"role":"declaration","source":0,"src_end":3016,"src_start":2779},{"artifact":0,"gen_end":19363,"gen_start":19188,"node":13,"role":"declaration","source":0,"src_end":3224,"src_start":3018},{"artifact":0,"gen_end":22429,"gen_start":19363,"node":14,"role":"declaration","source":0,"src_end":3485,"src_start":3226},{"artifact":0,"gen_end":42270,"gen_start":22429,"node":15,"role":"declaration","source":0,"src_end":4058,"src_start":3487},{"artifact":0,"gen_end":59582,"gen_start":42270,"node":16,"role":"declaration","source":0,"src_end":4600,"src_start":4060},{"artifact":0,"gen_end":59604,"gen_start":59582,"node":0,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":1,"gen_end":497,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":324,"src_start":145},{"artifact":1,"gen_end":794,"gen_start":497,"node":19,"role":"declaration","source":0,"src_end":448,"src_start":326},{"artifact":1,"gen_end":1045,"gen_start":794,"node":20,"role":"declaration","source":0,"src_end":588,"src_start":450},{"artifact":1,"gen_end":1428,"gen_start":1045,"node":21,"role":"declaration","source":0,"src_end":867,"src_start":590},{"artifact":1,"gen_end":1836,"gen_start":1428,"node":22,"role":"declaration","source":0,"src_end":1178,"src_start":869},{"artifact":1,"gen_end":3715,"gen_start":1836,"node":23,"role":"declaration","source":0,"src_end":1482,"src_start":1180},{"artifact":1,"gen_end":4133,"gen_start":3715,"node":24,"role":"declaration","source":0,"src_end":1785,"src_start":1484},{"artifact":1,"gen_end":4576,"gen_start":4133,"node":25,"role":"declaration","source":0,"src_end":2120,"src_start":1787},{"artifact":1,"gen_end":6863,"gen_start":4576,"node":26,"role":"declaration","source":0,"src_end":2513,"src_start":2122},{"artifact":1,"gen_end":7154,"gen_start":6863,"node":27,"role":"declaration","source":0,"src_end":2632,"src_start":2515},{"artifact":1,"gen_end":7525,"gen_start":7154,"node":28,"role":"declaration","source":0,"src_end":2777,"src_start":2634},{"artifact":1,"gen_end":7842,"gen_start":7525,"node":29,"role":"declaration","source":0,"src_end":3016,"src_start":2779},{"artifact":1,"gen_end":8490,"gen_start":7842,"node":30,"role":"declaration","source":0,"src_end":3224,"src_start":3018},{"artifact":1,"gen_end":8826,"gen_start":8490,"node":31,"role":"declaration","source":0,"src_end":3485,"src_start":3226},{"artifact":1,"gen_end":22640,"gen_start":8826,"node":32,"role":"declaration","source":0,"src_end":4058,"src_start":3487},{"artifact":1,"gen_end":34972,"gen_start":22640,"node":33,"role":"declaration","source":0,"src_end":4600,"src_start":4060},{"artifact":1,"gen_end":34987,"gen_start":34972,"node":17,"role":"declaration","source":0,"src_end":4636,"src_start":0}],"module":"Budget","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","sources":[{"id":0,"kind":"file","path":"src/Budget.lex.tex","sha256":"107fc5d7f6acd256caf10ae6a53953c04a86dacfc953d16196805f2f71aa835f"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Budget.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Budget.tex"}],"mappings":[{"artifact":0,"gen_end":351,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":0,"gen_end":494,"gen_start":351,"node":1,"role":"declaration","source":0,"src_end":324,"src_start":145},{"artifact":0,"gen_end":575,"gen_start":494,"node":2,"role":"declaration","source":0,"src_end":448,"src_start":326},{"artifact":0,"gen_end":576,"gen_start":575,"node":3,"role":"declaration","source":0,"src_end":588,"src_start":450},{"artifact":0,"gen_end":3685,"gen_start":576,"node":4,"role":"declaration","source":0,"src_end":867,"src_start":590},{"artifact":0,"gen_end":6823,"gen_start":3685,"node":5,"role":"declaration","source":0,"src_end":1178,"src_start":869},{"artifact":0,"gen_end":8110,"gen_start":6823,"node":6,"role":"declaration","source":0,"src_end":1482,"src_start":1180},{"artifact":0,"gen_end":11252,"gen_start":8110,"node":7,"role":"declaration","source":0,"src_end":1785,"src_start":1484},{"artifact":0,"gen_end":14423,"gen_start":11252,"node":8,"role":"declaration","source":0,"src_end":2120,"src_start":1787},{"artifact":0,"gen_end":15943,"gen_start":14423,"node":9,"role":"declaration","source":0,"src_end":2513,"src_start":2122},{"artifact":0,"gen_end":16030,"gen_start":15943,"node":10,"role":"declaration","source":0,"src_end":2632,"src_start":2515},{"artifact":0,"gen_end":16121,"gen_start":16030,"node":11,"role":"declaration","source":0,"src_end":2777,"src_start":2634},{"artifact":0,"gen_end":19188,"gen_start":16121,"node":12,"role":"declaration","source":0,"src_end":3016,"src_start":2779},{"artifact":0,"gen_end":19363,"gen_start":19188,"node":13,"role":"declaration","source":0,"src_end":3224,"src_start":3018},{"artifact":0,"gen_end":22429,"gen_start":19363,"node":14,"role":"declaration","source":0,"src_end":3485,"src_start":3226},{"artifact":0,"gen_end":42270,"gen_start":22429,"node":15,"role":"declaration","source":0,"src_end":4058,"src_start":3487},{"artifact":0,"gen_end":59582,"gen_start":42270,"node":16,"role":"declaration","source":0,"src_end":4600,"src_start":4060},{"artifact":0,"gen_end":59604,"gen_start":59582,"node":0,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":4636,"src_start":0},{"artifact":1,"gen_end":497,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":324,"src_start":145},{"artifact":1,"gen_end":794,"gen_start":497,"node":19,"role":"declaration","source":0,"src_end":448,"src_start":326},{"artifact":1,"gen_end":1045,"gen_start":794,"node":20,"role":"declaration","source":0,"src_end":588,"src_start":450},{"artifact":1,"gen_end":1428,"gen_start":1045,"node":21,"role":"declaration","source":0,"src_end":867,"src_start":590},{"artifact":1,"gen_end":1836,"gen_start":1428,"node":22,"role":"declaration","source":0,"src_end":1178,"src_start":869},{"artifact":1,"gen_end":3715,"gen_start":1836,"node":23,"role":"declaration","source":0,"src_end":1482,"src_start":1180},{"artifact":1,"gen_end":4133,"gen_start":3715,"node":24,"role":"declaration","source":0,"src_end":1785,"src_start":1484},{"artifact":1,"gen_end":4576,"gen_start":4133,"node":25,"role":"declaration","source":0,"src_end":2120,"src_start":1787},{"artifact":1,"gen_end":6863,"gen_start":4576,"node":26,"role":"declaration","source":0,"src_end":2513,"src_start":2122},{"artifact":1,"gen_end":7154,"gen_start":6863,"node":27,"role":"declaration","source":0,"src_end":2632,"src_start":2515},{"artifact":1,"gen_end":7525,"gen_start":7154,"node":28,"role":"declaration","source":0,"src_end":2777,"src_start":2634},{"artifact":1,"gen_end":7842,"gen_start":7525,"node":29,"role":"declaration","source":0,"src_end":3016,"src_start":2779},{"artifact":1,"gen_end":8490,"gen_start":7842,"node":30,"role":"declaration","source":0,"src_end":3224,"src_start":3018},{"artifact":1,"gen_end":8826,"gen_start":8490,"node":31,"role":"declaration","source":0,"src_end":3485,"src_start":3226},{"artifact":1,"gen_end":22640,"gen_start":8826,"node":32,"role":"declaration","source":0,"src_end":4058,"src_start":3487},{"artifact":1,"gen_end":34972,"gen_start":22640,"node":33,"role":"declaration","source":0,"src_end":4600,"src_start":4060},{"artifact":1,"gen_end":34987,"gen_start":34972,"node":17,"role":"declaration","source":0,"src_end":4636,"src_start":0}],"module":"Budget","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","sources":[{"id":0,"kind":"file","path":"src/Budget.lex.tex","sha256":"107fc5d7f6acd256caf10ae6a53953c04a86dacfc953d16196805f2f71aa835f"}],"spec":"lexlean/source-map/1"} diff --git a/examples/reasoning/expected/build/maps/Reasoning/Clinic.map.json b/examples/reasoning/expected/build/maps/Reasoning/Clinic.map.json index 704b9cbae..4f468dd74 100644 --- a/examples/reasoning/expected/build/maps/Reasoning/Clinic.map.json +++ b/examples/reasoning/expected/build/maps/Reasoning/Clinic.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Clinic.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Clinic.tex"}],"mappings":[{"artifact":0,"gen_end":351,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":0,"gen_end":498,"gen_start":351,"node":1,"role":"declaration","source":0,"src_end":440,"src_start":144},{"artifact":0,"gen_end":675,"gen_start":498,"node":2,"role":"declaration","source":0,"src_end":816,"src_start":442},{"artifact":0,"gen_end":763,"gen_start":675,"node":3,"role":"declaration","source":0,"src_end":954,"src_start":818},{"artifact":0,"gen_end":851,"gen_start":763,"node":4,"role":"declaration","source":0,"src_end":1092,"src_start":956},{"artifact":0,"gen_end":944,"gen_start":851,"node":5,"role":"declaration","source":0,"src_end":1235,"src_start":1094},{"artifact":0,"gen_end":1032,"gen_start":944,"node":6,"role":"declaration","source":0,"src_end":1373,"src_start":1237},{"artifact":0,"gen_end":1119,"gen_start":1032,"node":7,"role":"declaration","source":0,"src_end":1510,"src_start":1375},{"artifact":0,"gen_end":1207,"gen_start":1119,"node":8,"role":"declaration","source":0,"src_end":1626,"src_start":1512},{"artifact":0,"gen_end":1296,"gen_start":1207,"node":9,"role":"declaration","source":0,"src_end":1743,"src_start":1628},{"artifact":0,"gen_end":1390,"gen_start":1296,"node":10,"role":"declaration","source":0,"src_end":1865,"src_start":1745},{"artifact":0,"gen_end":1479,"gen_start":1390,"node":11,"role":"declaration","source":0,"src_end":1982,"src_start":1867},{"artifact":0,"gen_end":1567,"gen_start":1479,"node":12,"role":"declaration","source":0,"src_end":2098,"src_start":1984},{"artifact":0,"gen_end":1775,"gen_start":1567,"node":13,"role":"declaration","source":0,"src_end":2382,"src_start":2100},{"artifact":0,"gen_end":3252,"gen_start":1775,"node":14,"role":"declaration","source":0,"src_end":4502,"src_start":2384},{"artifact":0,"gen_end":3506,"gen_start":3252,"node":15,"role":"declaration","source":0,"src_end":4840,"src_start":4504},{"artifact":0,"gen_end":3986,"gen_start":3506,"node":16,"role":"declaration","source":0,"src_end":5303,"src_start":4842},{"artifact":0,"gen_end":7134,"gen_start":3986,"node":17,"role":"declaration","source":0,"src_end":5701,"src_start":5305},{"artifact":0,"gen_end":7306,"gen_start":7134,"node":18,"role":"declaration","source":0,"src_end":5935,"src_start":5703},{"artifact":0,"gen_end":10727,"gen_start":7306,"node":19,"role":"declaration","source":0,"src_end":6705,"src_start":5937},{"artifact":0,"gen_end":14121,"gen_start":10727,"node":20,"role":"declaration","source":0,"src_end":7354,"src_start":6707},{"artifact":0,"gen_end":15647,"gen_start":14121,"node":21,"role":"declaration","source":0,"src_end":7914,"src_start":7356},{"artifact":0,"gen_end":19077,"gen_start":15647,"node":22,"role":"declaration","source":0,"src_end":8693,"src_start":7916},{"artifact":0,"gen_end":22480,"gen_start":19077,"node":23,"role":"declaration","source":0,"src_end":9351,"src_start":8695},{"artifact":0,"gen_end":24099,"gen_start":22480,"node":24,"role":"declaration","source":0,"src_end":9932,"src_start":9353},{"artifact":0,"gen_end":27526,"gen_start":24099,"node":25,"role":"declaration","source":0,"src_end":10708,"src_start":9934},{"artifact":0,"gen_end":30926,"gen_start":27526,"node":26,"role":"declaration","source":0,"src_end":11363,"src_start":10710},{"artifact":0,"gen_end":32514,"gen_start":30926,"node":27,"role":"declaration","source":0,"src_end":11937,"src_start":11365},{"artifact":0,"gen_end":35944,"gen_start":32514,"node":28,"role":"declaration","source":0,"src_end":12716,"src_start":11939},{"artifact":0,"gen_end":39347,"gen_start":35944,"node":29,"role":"declaration","source":0,"src_end":13374,"src_start":12718},{"artifact":0,"gen_end":40980,"gen_start":39347,"node":30,"role":"declaration","source":0,"src_end":13957,"src_start":13376},{"artifact":0,"gen_end":44463,"gen_start":40980,"node":31,"role":"declaration","source":0,"src_end":14805,"src_start":13959},{"artifact":0,"gen_end":47919,"gen_start":44463,"node":32,"role":"declaration","source":0,"src_end":15532,"src_start":14807},{"artifact":0,"gen_end":49476,"gen_start":47919,"node":33,"role":"declaration","source":0,"src_end":16168,"src_start":15534},{"artifact":0,"gen_end":52945,"gen_start":49476,"node":34,"role":"declaration","source":0,"src_end":16984,"src_start":16170},{"artifact":0,"gen_end":56387,"gen_start":52945,"node":35,"role":"declaration","source":0,"src_end":17679,"src_start":16986},{"artifact":0,"gen_end":57958,"gen_start":56387,"node":36,"role":"declaration","source":0,"src_end":18287,"src_start":17681},{"artifact":0,"gen_end":61414,"gen_start":57958,"node":37,"role":"declaration","source":0,"src_end":19091,"src_start":18289},{"artifact":0,"gen_end":64843,"gen_start":61414,"node":38,"role":"declaration","source":0,"src_end":19774,"src_start":19093},{"artifact":0,"gen_end":66404,"gen_start":64843,"node":39,"role":"declaration","source":0,"src_end":20368,"src_start":19776},{"artifact":0,"gen_end":70001,"gen_start":66404,"node":40,"role":"declaration","source":0,"src_end":21308,"src_start":20370},{"artifact":0,"gen_end":73571,"gen_start":70001,"node":41,"role":"declaration","source":0,"src_end":22127,"src_start":21310},{"artifact":0,"gen_end":75298,"gen_start":73571,"node":42,"role":"declaration","source":0,"src_end":22863,"src_start":22129},{"artifact":0,"gen_end":75480,"gen_start":75298,"node":43,"role":"declaration","source":0,"src_end":23072,"src_start":22865},{"artifact":0,"gen_end":75694,"gen_start":75480,"node":44,"role":"declaration","source":0,"src_end":23321,"src_start":23074},{"artifact":0,"gen_end":78901,"gen_start":75694,"node":45,"role":"declaration","source":0,"src_end":23800,"src_start":23323},{"artifact":0,"gen_end":82111,"gen_start":78901,"node":46,"role":"declaration","source":0,"src_end":24282,"src_start":23802},{"artifact":0,"gen_end":82477,"gen_start":82111,"node":47,"role":"declaration","source":0,"src_end":24566,"src_start":24284},{"artifact":0,"gen_end":82563,"gen_start":82477,"node":48,"role":"declaration","source":0,"src_end":24660,"src_start":24568},{"artifact":0,"gen_end":82652,"gen_start":82563,"node":49,"role":"declaration","source":0,"src_end":24789,"src_start":24662},{"artifact":0,"gen_end":85727,"gen_start":82652,"node":50,"role":"declaration","source":0,"src_end":25020,"src_start":24791},{"artifact":0,"gen_end":85893,"gen_start":85727,"node":51,"role":"declaration","source":0,"src_end":25224,"src_start":25022},{"artifact":0,"gen_end":89054,"gen_start":85893,"node":52,"role":"declaration","source":0,"src_end":25579,"src_start":25226},{"artifact":0,"gen_end":92213,"gen_start":89054,"node":53,"role":"declaration","source":0,"src_end":25914,"src_start":25581},{"artifact":0,"gen_end":116886,"gen_start":92213,"node":54,"role":"declaration","source":0,"src_end":26711,"src_start":25916},{"artifact":0,"gen_end":139633,"gen_start":116886,"node":55,"role":"declaration","source":0,"src_end":27403,"src_start":26713},{"artifact":0,"gen_end":139655,"gen_start":139633,"node":0,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":56,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":1,"gen_end":536,"gen_start":134,"node":57,"role":"declaration","source":0,"src_end":440,"src_start":144},{"artifact":1,"gen_end":1076,"gen_start":536,"node":58,"role":"declaration","source":0,"src_end":816,"src_start":442},{"artifact":1,"gen_end":1411,"gen_start":1076,"node":59,"role":"declaration","source":0,"src_end":954,"src_start":818},{"artifact":1,"gen_end":1746,"gen_start":1411,"node":60,"role":"declaration","source":0,"src_end":1092,"src_start":956},{"artifact":1,"gen_end":2086,"gen_start":1746,"node":61,"role":"declaration","source":0,"src_end":1235,"src_start":1094},{"artifact":1,"gen_end":2421,"gen_start":2086,"node":62,"role":"declaration","source":0,"src_end":1373,"src_start":1237},{"artifact":1,"gen_end":2755,"gen_start":2421,"node":63,"role":"declaration","source":0,"src_end":1510,"src_start":1375},{"artifact":1,"gen_end":3014,"gen_start":2755,"node":64,"role":"declaration","source":0,"src_end":1626,"src_start":1512},{"artifact":1,"gen_end":3274,"gen_start":3014,"node":65,"role":"declaration","source":0,"src_end":1743,"src_start":1628},{"artifact":1,"gen_end":3539,"gen_start":3274,"node":66,"role":"declaration","source":0,"src_end":1865,"src_start":1745},{"artifact":1,"gen_end":3799,"gen_start":3539,"node":67,"role":"declaration","source":0,"src_end":1982,"src_start":1867},{"artifact":1,"gen_end":4058,"gen_start":3799,"node":68,"role":"declaration","source":0,"src_end":2098,"src_start":1984},{"artifact":1,"gen_end":4482,"gen_start":4058,"node":69,"role":"declaration","source":0,"src_end":2382,"src_start":2100},{"artifact":1,"gen_end":6595,"gen_start":4482,"node":70,"role":"declaration","source":0,"src_end":4502,"src_start":2384},{"artifact":1,"gen_end":7125,"gen_start":6595,"node":71,"role":"declaration","source":0,"src_end":4840,"src_start":4504},{"artifact":1,"gen_end":7787,"gen_start":7125,"node":72,"role":"declaration","source":0,"src_end":5303,"src_start":4842},{"artifact":1,"gen_end":8107,"gen_start":7787,"node":73,"role":"declaration","source":0,"src_end":5701,"src_start":5305},{"artifact":1,"gen_end":8840,"gen_start":8107,"node":74,"role":"declaration","source":0,"src_end":5935,"src_start":5703},{"artifact":1,"gen_end":9389,"gen_start":8840,"node":75,"role":"declaration","source":0,"src_end":6705,"src_start":5937},{"artifact":1,"gen_end":9953,"gen_start":9389,"node":76,"role":"declaration","source":0,"src_end":7354,"src_start":6707},{"artifact":1,"gen_end":12552,"gen_start":9953,"node":77,"role":"declaration","source":0,"src_end":7914,"src_start":7356},{"artifact":1,"gen_end":13110,"gen_start":12552,"node":78,"role":"declaration","source":0,"src_end":8693,"src_start":7916},{"artifact":1,"gen_end":13683,"gen_start":13110,"node":79,"role":"declaration","source":0,"src_end":9351,"src_start":8695},{"artifact":1,"gen_end":16390,"gen_start":13683,"node":80,"role":"declaration","source":0,"src_end":9932,"src_start":9353},{"artifact":1,"gen_end":16945,"gen_start":16390,"node":81,"role":"declaration","source":0,"src_end":10708,"src_start":9934},{"artifact":1,"gen_end":17515,"gen_start":16945,"node":82,"role":"declaration","source":0,"src_end":11363,"src_start":10710},{"artifact":1,"gen_end":20186,"gen_start":17515,"node":83,"role":"declaration","source":0,"src_end":11937,"src_start":11365},{"artifact":1,"gen_end":20744,"gen_start":20186,"node":84,"role":"declaration","source":0,"src_end":12716,"src_start":11939},{"artifact":1,"gen_end":21317,"gen_start":20744,"node":85,"role":"declaration","source":0,"src_end":13374,"src_start":12718},{"artifact":1,"gen_end":24036,"gen_start":21317,"node":86,"role":"declaration","source":0,"src_end":13957,"src_start":13376},{"artifact":1,"gen_end":24647,"gen_start":24036,"node":87,"role":"declaration","source":0,"src_end":14805,"src_start":13959},{"artifact":1,"gen_end":25273,"gen_start":24647,"node":88,"role":"declaration","source":0,"src_end":15532,"src_start":14807},{"artifact":1,"gen_end":28108,"gen_start":25273,"node":89,"role":"declaration","source":0,"src_end":16168,"src_start":15534},{"artifact":1,"gen_end":28707,"gen_start":28108,"node":90,"role":"declaration","source":0,"src_end":16984,"src_start":16170},{"artifact":1,"gen_end":29321,"gen_start":28707,"node":91,"role":"declaration","source":0,"src_end":17679,"src_start":16986},{"artifact":1,"gen_end":32132,"gen_start":29321,"node":92,"role":"declaration","source":0,"src_end":18287,"src_start":17681},{"artifact":1,"gen_end":32718,"gen_start":32132,"node":93,"role":"declaration","source":0,"src_end":19091,"src_start":18289},{"artifact":1,"gen_end":33319,"gen_start":32718,"node":94,"role":"declaration","source":0,"src_end":19774,"src_start":19093},{"artifact":1,"gen_end":36066,"gen_start":33319,"node":95,"role":"declaration","source":0,"src_end":20368,"src_start":19776},{"artifact":1,"gen_end":36797,"gen_start":36066,"node":96,"role":"declaration","source":0,"src_end":21308,"src_start":20370},{"artifact":1,"gen_end":37543,"gen_start":36797,"node":97,"role":"declaration","source":0,"src_end":22127,"src_start":21310},{"artifact":1,"gen_end":40906,"gen_start":37543,"node":98,"role":"declaration","source":0,"src_end":22863,"src_start":22129},{"artifact":1,"gen_end":41319,"gen_start":40906,"node":99,"role":"declaration","source":0,"src_end":23072,"src_start":22865},{"artifact":1,"gen_end":41788,"gen_start":41319,"node":100,"role":"declaration","source":0,"src_end":23321,"src_start":23074},{"artifact":1,"gen_end":42109,"gen_start":41788,"node":101,"role":"declaration","source":0,"src_end":23800,"src_start":23323},{"artifact":1,"gen_end":42433,"gen_start":42109,"node":102,"role":"declaration","source":0,"src_end":24282,"src_start":23802},{"artifact":1,"gen_end":43603,"gen_start":42433,"node":103,"role":"declaration","source":0,"src_end":24566,"src_start":24284},{"artifact":1,"gen_end":43859,"gen_start":43603,"node":104,"role":"declaration","source":0,"src_end":24660,"src_start":24568},{"artifact":1,"gen_end":44194,"gen_start":43859,"node":105,"role":"declaration","source":0,"src_end":24789,"src_start":24662},{"artifact":1,"gen_end":44476,"gen_start":44194,"node":106,"role":"declaration","source":0,"src_end":25020,"src_start":24791},{"artifact":1,"gen_end":45162,"gen_start":44476,"node":107,"role":"declaration","source":0,"src_end":25224,"src_start":25022},{"artifact":1,"gen_end":45578,"gen_start":45162,"node":108,"role":"declaration","source":0,"src_end":25579,"src_start":25226},{"artifact":1,"gen_end":45977,"gen_start":45578,"node":109,"role":"declaration","source":0,"src_end":25914,"src_start":25581},{"artifact":1,"gen_end":62729,"gen_start":45977,"node":110,"role":"declaration","source":0,"src_end":26711,"src_start":25916},{"artifact":1,"gen_end":78144,"gen_start":62729,"node":111,"role":"declaration","source":0,"src_end":27403,"src_start":26713},{"artifact":1,"gen_end":78159,"gen_start":78144,"node":56,"role":"declaration","source":0,"src_end":27439,"src_start":0}],"module":"Clinic","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-latex-module"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"}],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","sources":[{"id":0,"kind":"file","path":"src/Clinic.lex.tex","sha256":"01d7ef34f88ff99c06d1bd95d1e580e88e2b75b2d2826bfce7462f6514d1d05a"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Clinic.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Clinic.tex"}],"mappings":[{"artifact":0,"gen_end":351,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":0,"gen_end":498,"gen_start":351,"node":1,"role":"declaration","source":0,"src_end":440,"src_start":144},{"artifact":0,"gen_end":675,"gen_start":498,"node":2,"role":"declaration","source":0,"src_end":816,"src_start":442},{"artifact":0,"gen_end":763,"gen_start":675,"node":3,"role":"declaration","source":0,"src_end":954,"src_start":818},{"artifact":0,"gen_end":851,"gen_start":763,"node":4,"role":"declaration","source":0,"src_end":1092,"src_start":956},{"artifact":0,"gen_end":944,"gen_start":851,"node":5,"role":"declaration","source":0,"src_end":1235,"src_start":1094},{"artifact":0,"gen_end":1032,"gen_start":944,"node":6,"role":"declaration","source":0,"src_end":1373,"src_start":1237},{"artifact":0,"gen_end":1119,"gen_start":1032,"node":7,"role":"declaration","source":0,"src_end":1510,"src_start":1375},{"artifact":0,"gen_end":1207,"gen_start":1119,"node":8,"role":"declaration","source":0,"src_end":1626,"src_start":1512},{"artifact":0,"gen_end":1296,"gen_start":1207,"node":9,"role":"declaration","source":0,"src_end":1743,"src_start":1628},{"artifact":0,"gen_end":1390,"gen_start":1296,"node":10,"role":"declaration","source":0,"src_end":1865,"src_start":1745},{"artifact":0,"gen_end":1479,"gen_start":1390,"node":11,"role":"declaration","source":0,"src_end":1982,"src_start":1867},{"artifact":0,"gen_end":1567,"gen_start":1479,"node":12,"role":"declaration","source":0,"src_end":2098,"src_start":1984},{"artifact":0,"gen_end":1775,"gen_start":1567,"node":13,"role":"declaration","source":0,"src_end":2382,"src_start":2100},{"artifact":0,"gen_end":3252,"gen_start":1775,"node":14,"role":"declaration","source":0,"src_end":4502,"src_start":2384},{"artifact":0,"gen_end":3506,"gen_start":3252,"node":15,"role":"declaration","source":0,"src_end":4840,"src_start":4504},{"artifact":0,"gen_end":3986,"gen_start":3506,"node":16,"role":"declaration","source":0,"src_end":5303,"src_start":4842},{"artifact":0,"gen_end":7134,"gen_start":3986,"node":17,"role":"declaration","source":0,"src_end":5701,"src_start":5305},{"artifact":0,"gen_end":7306,"gen_start":7134,"node":18,"role":"declaration","source":0,"src_end":5935,"src_start":5703},{"artifact":0,"gen_end":10727,"gen_start":7306,"node":19,"role":"declaration","source":0,"src_end":6705,"src_start":5937},{"artifact":0,"gen_end":14121,"gen_start":10727,"node":20,"role":"declaration","source":0,"src_end":7354,"src_start":6707},{"artifact":0,"gen_end":15647,"gen_start":14121,"node":21,"role":"declaration","source":0,"src_end":7914,"src_start":7356},{"artifact":0,"gen_end":19077,"gen_start":15647,"node":22,"role":"declaration","source":0,"src_end":8693,"src_start":7916},{"artifact":0,"gen_end":22480,"gen_start":19077,"node":23,"role":"declaration","source":0,"src_end":9351,"src_start":8695},{"artifact":0,"gen_end":24099,"gen_start":22480,"node":24,"role":"declaration","source":0,"src_end":9932,"src_start":9353},{"artifact":0,"gen_end":27526,"gen_start":24099,"node":25,"role":"declaration","source":0,"src_end":10708,"src_start":9934},{"artifact":0,"gen_end":30926,"gen_start":27526,"node":26,"role":"declaration","source":0,"src_end":11363,"src_start":10710},{"artifact":0,"gen_end":32514,"gen_start":30926,"node":27,"role":"declaration","source":0,"src_end":11937,"src_start":11365},{"artifact":0,"gen_end":35944,"gen_start":32514,"node":28,"role":"declaration","source":0,"src_end":12716,"src_start":11939},{"artifact":0,"gen_end":39347,"gen_start":35944,"node":29,"role":"declaration","source":0,"src_end":13374,"src_start":12718},{"artifact":0,"gen_end":40980,"gen_start":39347,"node":30,"role":"declaration","source":0,"src_end":13957,"src_start":13376},{"artifact":0,"gen_end":44463,"gen_start":40980,"node":31,"role":"declaration","source":0,"src_end":14805,"src_start":13959},{"artifact":0,"gen_end":47919,"gen_start":44463,"node":32,"role":"declaration","source":0,"src_end":15532,"src_start":14807},{"artifact":0,"gen_end":49476,"gen_start":47919,"node":33,"role":"declaration","source":0,"src_end":16168,"src_start":15534},{"artifact":0,"gen_end":52945,"gen_start":49476,"node":34,"role":"declaration","source":0,"src_end":16984,"src_start":16170},{"artifact":0,"gen_end":56387,"gen_start":52945,"node":35,"role":"declaration","source":0,"src_end":17679,"src_start":16986},{"artifact":0,"gen_end":57958,"gen_start":56387,"node":36,"role":"declaration","source":0,"src_end":18287,"src_start":17681},{"artifact":0,"gen_end":61414,"gen_start":57958,"node":37,"role":"declaration","source":0,"src_end":19091,"src_start":18289},{"artifact":0,"gen_end":64843,"gen_start":61414,"node":38,"role":"declaration","source":0,"src_end":19774,"src_start":19093},{"artifact":0,"gen_end":66404,"gen_start":64843,"node":39,"role":"declaration","source":0,"src_end":20368,"src_start":19776},{"artifact":0,"gen_end":70001,"gen_start":66404,"node":40,"role":"declaration","source":0,"src_end":21308,"src_start":20370},{"artifact":0,"gen_end":73571,"gen_start":70001,"node":41,"role":"declaration","source":0,"src_end":22127,"src_start":21310},{"artifact":0,"gen_end":75298,"gen_start":73571,"node":42,"role":"declaration","source":0,"src_end":22863,"src_start":22129},{"artifact":0,"gen_end":75480,"gen_start":75298,"node":43,"role":"declaration","source":0,"src_end":23072,"src_start":22865},{"artifact":0,"gen_end":75694,"gen_start":75480,"node":44,"role":"declaration","source":0,"src_end":23321,"src_start":23074},{"artifact":0,"gen_end":78901,"gen_start":75694,"node":45,"role":"declaration","source":0,"src_end":23800,"src_start":23323},{"artifact":0,"gen_end":82111,"gen_start":78901,"node":46,"role":"declaration","source":0,"src_end":24282,"src_start":23802},{"artifact":0,"gen_end":82477,"gen_start":82111,"node":47,"role":"declaration","source":0,"src_end":24566,"src_start":24284},{"artifact":0,"gen_end":82563,"gen_start":82477,"node":48,"role":"declaration","source":0,"src_end":24660,"src_start":24568},{"artifact":0,"gen_end":82652,"gen_start":82563,"node":49,"role":"declaration","source":0,"src_end":24789,"src_start":24662},{"artifact":0,"gen_end":85727,"gen_start":82652,"node":50,"role":"declaration","source":0,"src_end":25020,"src_start":24791},{"artifact":0,"gen_end":85893,"gen_start":85727,"node":51,"role":"declaration","source":0,"src_end":25224,"src_start":25022},{"artifact":0,"gen_end":89054,"gen_start":85893,"node":52,"role":"declaration","source":0,"src_end":25579,"src_start":25226},{"artifact":0,"gen_end":92213,"gen_start":89054,"node":53,"role":"declaration","source":0,"src_end":25914,"src_start":25581},{"artifact":0,"gen_end":116886,"gen_start":92213,"node":54,"role":"declaration","source":0,"src_end":26711,"src_start":25916},{"artifact":0,"gen_end":139633,"gen_start":116886,"node":55,"role":"declaration","source":0,"src_end":27403,"src_start":26713},{"artifact":0,"gen_end":139655,"gen_start":139633,"node":0,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":56,"role":"declaration","source":0,"src_end":27439,"src_start":0},{"artifact":1,"gen_end":536,"gen_start":134,"node":57,"role":"declaration","source":0,"src_end":440,"src_start":144},{"artifact":1,"gen_end":1076,"gen_start":536,"node":58,"role":"declaration","source":0,"src_end":816,"src_start":442},{"artifact":1,"gen_end":1411,"gen_start":1076,"node":59,"role":"declaration","source":0,"src_end":954,"src_start":818},{"artifact":1,"gen_end":1746,"gen_start":1411,"node":60,"role":"declaration","source":0,"src_end":1092,"src_start":956},{"artifact":1,"gen_end":2086,"gen_start":1746,"node":61,"role":"declaration","source":0,"src_end":1235,"src_start":1094},{"artifact":1,"gen_end":2421,"gen_start":2086,"node":62,"role":"declaration","source":0,"src_end":1373,"src_start":1237},{"artifact":1,"gen_end":2755,"gen_start":2421,"node":63,"role":"declaration","source":0,"src_end":1510,"src_start":1375},{"artifact":1,"gen_end":3014,"gen_start":2755,"node":64,"role":"declaration","source":0,"src_end":1626,"src_start":1512},{"artifact":1,"gen_end":3274,"gen_start":3014,"node":65,"role":"declaration","source":0,"src_end":1743,"src_start":1628},{"artifact":1,"gen_end":3539,"gen_start":3274,"node":66,"role":"declaration","source":0,"src_end":1865,"src_start":1745},{"artifact":1,"gen_end":3799,"gen_start":3539,"node":67,"role":"declaration","source":0,"src_end":1982,"src_start":1867},{"artifact":1,"gen_end":4058,"gen_start":3799,"node":68,"role":"declaration","source":0,"src_end":2098,"src_start":1984},{"artifact":1,"gen_end":4482,"gen_start":4058,"node":69,"role":"declaration","source":0,"src_end":2382,"src_start":2100},{"artifact":1,"gen_end":6595,"gen_start":4482,"node":70,"role":"declaration","source":0,"src_end":4502,"src_start":2384},{"artifact":1,"gen_end":7125,"gen_start":6595,"node":71,"role":"declaration","source":0,"src_end":4840,"src_start":4504},{"artifact":1,"gen_end":7787,"gen_start":7125,"node":72,"role":"declaration","source":0,"src_end":5303,"src_start":4842},{"artifact":1,"gen_end":8107,"gen_start":7787,"node":73,"role":"declaration","source":0,"src_end":5701,"src_start":5305},{"artifact":1,"gen_end":8840,"gen_start":8107,"node":74,"role":"declaration","source":0,"src_end":5935,"src_start":5703},{"artifact":1,"gen_end":9389,"gen_start":8840,"node":75,"role":"declaration","source":0,"src_end":6705,"src_start":5937},{"artifact":1,"gen_end":9953,"gen_start":9389,"node":76,"role":"declaration","source":0,"src_end":7354,"src_start":6707},{"artifact":1,"gen_end":12552,"gen_start":9953,"node":77,"role":"declaration","source":0,"src_end":7914,"src_start":7356},{"artifact":1,"gen_end":13110,"gen_start":12552,"node":78,"role":"declaration","source":0,"src_end":8693,"src_start":7916},{"artifact":1,"gen_end":13683,"gen_start":13110,"node":79,"role":"declaration","source":0,"src_end":9351,"src_start":8695},{"artifact":1,"gen_end":16390,"gen_start":13683,"node":80,"role":"declaration","source":0,"src_end":9932,"src_start":9353},{"artifact":1,"gen_end":16945,"gen_start":16390,"node":81,"role":"declaration","source":0,"src_end":10708,"src_start":9934},{"artifact":1,"gen_end":17515,"gen_start":16945,"node":82,"role":"declaration","source":0,"src_end":11363,"src_start":10710},{"artifact":1,"gen_end":20186,"gen_start":17515,"node":83,"role":"declaration","source":0,"src_end":11937,"src_start":11365},{"artifact":1,"gen_end":20744,"gen_start":20186,"node":84,"role":"declaration","source":0,"src_end":12716,"src_start":11939},{"artifact":1,"gen_end":21317,"gen_start":20744,"node":85,"role":"declaration","source":0,"src_end":13374,"src_start":12718},{"artifact":1,"gen_end":24036,"gen_start":21317,"node":86,"role":"declaration","source":0,"src_end":13957,"src_start":13376},{"artifact":1,"gen_end":24647,"gen_start":24036,"node":87,"role":"declaration","source":0,"src_end":14805,"src_start":13959},{"artifact":1,"gen_end":25273,"gen_start":24647,"node":88,"role":"declaration","source":0,"src_end":15532,"src_start":14807},{"artifact":1,"gen_end":28108,"gen_start":25273,"node":89,"role":"declaration","source":0,"src_end":16168,"src_start":15534},{"artifact":1,"gen_end":28707,"gen_start":28108,"node":90,"role":"declaration","source":0,"src_end":16984,"src_start":16170},{"artifact":1,"gen_end":29321,"gen_start":28707,"node":91,"role":"declaration","source":0,"src_end":17679,"src_start":16986},{"artifact":1,"gen_end":32132,"gen_start":29321,"node":92,"role":"declaration","source":0,"src_end":18287,"src_start":17681},{"artifact":1,"gen_end":32718,"gen_start":32132,"node":93,"role":"declaration","source":0,"src_end":19091,"src_start":18289},{"artifact":1,"gen_end":33319,"gen_start":32718,"node":94,"role":"declaration","source":0,"src_end":19774,"src_start":19093},{"artifact":1,"gen_end":36066,"gen_start":33319,"node":95,"role":"declaration","source":0,"src_end":20368,"src_start":19776},{"artifact":1,"gen_end":36797,"gen_start":36066,"node":96,"role":"declaration","source":0,"src_end":21308,"src_start":20370},{"artifact":1,"gen_end":37543,"gen_start":36797,"node":97,"role":"declaration","source":0,"src_end":22127,"src_start":21310},{"artifact":1,"gen_end":40906,"gen_start":37543,"node":98,"role":"declaration","source":0,"src_end":22863,"src_start":22129},{"artifact":1,"gen_end":41319,"gen_start":40906,"node":99,"role":"declaration","source":0,"src_end":23072,"src_start":22865},{"artifact":1,"gen_end":41788,"gen_start":41319,"node":100,"role":"declaration","source":0,"src_end":23321,"src_start":23074},{"artifact":1,"gen_end":42109,"gen_start":41788,"node":101,"role":"declaration","source":0,"src_end":23800,"src_start":23323},{"artifact":1,"gen_end":42433,"gen_start":42109,"node":102,"role":"declaration","source":0,"src_end":24282,"src_start":23802},{"artifact":1,"gen_end":43603,"gen_start":42433,"node":103,"role":"declaration","source":0,"src_end":24566,"src_start":24284},{"artifact":1,"gen_end":43859,"gen_start":43603,"node":104,"role":"declaration","source":0,"src_end":24660,"src_start":24568},{"artifact":1,"gen_end":44194,"gen_start":43859,"node":105,"role":"declaration","source":0,"src_end":24789,"src_start":24662},{"artifact":1,"gen_end":44476,"gen_start":44194,"node":106,"role":"declaration","source":0,"src_end":25020,"src_start":24791},{"artifact":1,"gen_end":45162,"gen_start":44476,"node":107,"role":"declaration","source":0,"src_end":25224,"src_start":25022},{"artifact":1,"gen_end":45578,"gen_start":45162,"node":108,"role":"declaration","source":0,"src_end":25579,"src_start":25226},{"artifact":1,"gen_end":45977,"gen_start":45578,"node":109,"role":"declaration","source":0,"src_end":25914,"src_start":25581},{"artifact":1,"gen_end":62729,"gen_start":45977,"node":110,"role":"declaration","source":0,"src_end":26711,"src_start":25916},{"artifact":1,"gen_end":78144,"gen_start":62729,"node":111,"role":"declaration","source":0,"src_end":27403,"src_start":26713},{"artifact":1,"gen_end":78159,"gen_start":78144,"node":56,"role":"declaration","source":0,"src_end":27439,"src_start":0}],"module":"Clinic","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-latex-module"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"}],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","sources":[{"id":0,"kind":"file","path":"src/Clinic.lex.tex","sha256":"01d7ef34f88ff99c06d1bd95d1e580e88e2b75b2d2826bfce7462f6514d1d05a"}],"spec":"lexlean/source-map/1"} diff --git a/examples/reasoning/expected/build/maps/Reasoning/Main.map.json b/examples/reasoning/expected/build/maps/Reasoning/Main.map.json index a1319f629..2de47e452 100644 --- a/examples/reasoning/expected/build/maps/Reasoning/Main.map.json +++ b/examples/reasoning/expected/build/maps/Reasoning/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Main.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Main.tex"}],"mappings":[{"artifact":0,"gen_end":513,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":0,"gen_end":715,"gen_start":513,"node":1,"role":"declaration","source":0,"src_end":460,"src_start":234},{"artifact":0,"gen_end":716,"gen_start":715,"node":2,"role":"declaration","source":0,"src_end":626,"src_start":462},{"artifact":0,"gen_end":855,"gen_start":716,"node":3,"role":"declaration","source":0,"src_end":830,"src_start":628},{"artifact":0,"gen_end":1007,"gen_start":855,"node":4,"role":"declaration","source":0,"src_end":1068,"src_start":832},{"artifact":0,"gen_end":1177,"gen_start":1007,"node":5,"role":"declaration","source":0,"src_end":1290,"src_start":1070},{"artifact":0,"gen_end":1324,"gen_start":1177,"node":6,"role":"declaration","source":0,"src_end":1441,"src_start":1292},{"artifact":0,"gen_end":1474,"gen_start":1324,"node":7,"role":"declaration","source":0,"src_end":1592,"src_start":1443},{"artifact":0,"gen_end":1640,"gen_start":1474,"node":8,"role":"declaration","source":0,"src_end":1776,"src_start":1594},{"artifact":0,"gen_end":4775,"gen_start":1640,"node":9,"role":"declaration","source":0,"src_end":2078,"src_start":1778},{"artifact":0,"gen_end":4920,"gen_start":4775,"node":10,"role":"declaration","source":0,"src_end":2305,"src_start":2080},{"artifact":0,"gen_end":5224,"gen_start":4920,"node":11,"role":"declaration","source":0,"src_end":2682,"src_start":2307},{"artifact":0,"gen_end":5528,"gen_start":5224,"node":12,"role":"declaration","source":0,"src_end":3041,"src_start":2684},{"artifact":0,"gen_end":5818,"gen_start":5528,"node":13,"role":"declaration","source":0,"src_end":3345,"src_start":3043},{"artifact":0,"gen_end":9083,"gen_start":5818,"node":14,"role":"declaration","source":0,"src_end":3765,"src_start":3347},{"artifact":0,"gen_end":12456,"gen_start":9083,"node":15,"role":"declaration","source":0,"src_end":4281,"src_start":3767},{"artifact":0,"gen_end":15692,"gen_start":12456,"node":16,"role":"declaration","source":0,"src_end":4695,"src_start":4283},{"artifact":0,"gen_end":40686,"gen_start":15692,"node":17,"role":"declaration","source":0,"src_end":5734,"src_start":4697},{"artifact":0,"gen_end":40786,"gen_start":40686,"node":18,"role":"declaration","source":0,"src_end":5833,"src_start":5736},{"artifact":0,"gen_end":40889,"gen_start":40786,"node":19,"role":"declaration","source":0,"src_end":5968,"src_start":5835},{"artifact":0,"gen_end":43964,"gen_start":40889,"node":20,"role":"declaration","source":0,"src_end":6190,"src_start":5970},{"artifact":0,"gen_end":44111,"gen_start":43964,"node":21,"role":"declaration","source":0,"src_end":6389,"src_start":6192},{"artifact":0,"gen_end":47300,"gen_start":44111,"node":22,"role":"declaration","source":0,"src_end":6731,"src_start":6391},{"artifact":0,"gen_end":68181,"gen_start":47300,"node":23,"role":"declaration","source":0,"src_end":7608,"src_start":6733},{"artifact":0,"gen_end":68627,"gen_start":68181,"node":24,"role":"declaration","source":0,"src_end":8192,"src_start":7610},{"artifact":0,"gen_end":69055,"gen_start":68627,"node":25,"role":"declaration","source":0,"src_end":8767,"src_start":8194},{"artifact":0,"gen_end":69537,"gen_start":69055,"node":26,"role":"declaration","source":0,"src_end":9391,"src_start":8769},{"artifact":0,"gen_end":69696,"gen_start":69537,"node":27,"role":"declaration","source":0,"src_end":9707,"src_start":9393},{"artifact":0,"gen_end":69844,"gen_start":69696,"node":28,"role":"declaration","source":0,"src_end":9979,"src_start":9709},{"artifact":0,"gen_end":70271,"gen_start":69844,"node":29,"role":"declaration","source":0,"src_end":10553,"src_start":9981},{"artifact":0,"gen_end":70422,"gen_start":70271,"node":30,"role":"declaration","source":0,"src_end":10828,"src_start":10555},{"artifact":0,"gen_end":70579,"gen_start":70422,"node":31,"role":"declaration","source":0,"src_end":11117,"src_start":10830},{"artifact":0,"gen_end":71280,"gen_start":70579,"node":32,"role":"declaration","source":0,"src_end":11892,"src_start":11119},{"artifact":0,"gen_end":71372,"gen_start":71280,"node":33,"role":"declaration","source":0,"src_end":12020,"src_start":11894},{"artifact":0,"gen_end":72083,"gen_start":71372,"node":34,"role":"declaration","source":0,"src_end":12754,"src_start":12022},{"artifact":0,"gen_end":72336,"gen_start":72083,"node":35,"role":"declaration","source":0,"src_end":13058,"src_start":12756},{"artifact":0,"gen_end":72609,"gen_start":72336,"node":36,"role":"declaration","source":0,"src_end":13405,"src_start":13060},{"artifact":0,"gen_end":72964,"gen_start":72609,"node":37,"role":"declaration","source":0,"src_end":13816,"src_start":13407},{"artifact":0,"gen_end":73273,"gen_start":72964,"node":38,"role":"declaration","source":0,"src_end":14166,"src_start":13818},{"artifact":0,"gen_end":73549,"gen_start":73273,"node":39,"role":"declaration","source":0,"src_end":14502,"src_start":14168},{"artifact":0,"gen_end":73823,"gen_start":73549,"node":40,"role":"declaration","source":0,"src_end":14836,"src_start":14504},{"artifact":0,"gen_end":73917,"gen_start":73823,"node":41,"role":"declaration","source":0,"src_end":14966,"src_start":14838},{"artifact":0,"gen_end":74224,"gen_start":73917,"node":42,"role":"declaration","source":0,"src_end":15380,"src_start":14968},{"artifact":0,"gen_end":74323,"gen_start":74224,"node":43,"role":"declaration","source":0,"src_end":15545,"src_start":15382},{"artifact":0,"gen_end":74457,"gen_start":74323,"node":44,"role":"declaration","source":0,"src_end":15745,"src_start":15547},{"artifact":0,"gen_end":74674,"gen_start":74457,"node":45,"role":"declaration","source":0,"src_end":16068,"src_start":15747},{"artifact":0,"gen_end":74805,"gen_start":74674,"node":46,"role":"declaration","source":0,"src_end":16294,"src_start":16070},{"artifact":0,"gen_end":74910,"gen_start":74805,"node":47,"role":"declaration","source":0,"src_end":16477,"src_start":16296},{"artifact":0,"gen_end":75103,"gen_start":74910,"node":48,"role":"declaration","source":0,"src_end":16751,"src_start":16479},{"artifact":0,"gen_end":75193,"gen_start":75103,"node":49,"role":"declaration","source":0,"src_end":16877,"src_start":16753},{"artifact":0,"gen_end":75380,"gen_start":75193,"node":50,"role":"declaration","source":0,"src_end":17143,"src_start":16879},{"artifact":0,"gen_end":75517,"gen_start":75380,"node":51,"role":"declaration","source":0,"src_end":17346,"src_start":17145},{"artifact":0,"gen_end":75658,"gen_start":75517,"node":52,"role":"declaration","source":0,"src_end":17553,"src_start":17348},{"artifact":0,"gen_end":76881,"gen_start":75658,"node":53,"role":"declaration","source":0,"src_end":18780,"src_start":17555},{"artifact":0,"gen_end":78100,"gen_start":76881,"node":54,"role":"declaration","source":0,"src_end":20003,"src_start":18782},{"artifact":0,"gen_end":79321,"gen_start":78100,"node":55,"role":"declaration","source":0,"src_end":21228,"src_start":20005},{"artifact":0,"gen_end":80435,"gen_start":79321,"node":56,"role":"declaration","source":0,"src_end":22400,"src_start":21230},{"artifact":0,"gen_end":81545,"gen_start":80435,"node":57,"role":"declaration","source":0,"src_end":23568,"src_start":22402},{"artifact":0,"gen_end":82775,"gen_start":81545,"node":58,"role":"declaration","source":0,"src_end":24802,"src_start":23570},{"artifact":0,"gen_end":83214,"gen_start":82775,"node":59,"role":"declaration","source":0,"src_end":25281,"src_start":24804},{"artifact":0,"gen_end":83594,"gen_start":83214,"node":60,"role":"declaration","source":0,"src_end":25701,"src_start":25283},{"artifact":0,"gen_end":83984,"gen_start":83594,"node":61,"role":"declaration","source":0,"src_end":26131,"src_start":25703},{"artifact":0,"gen_end":84411,"gen_start":83984,"node":62,"role":"declaration","source":0,"src_end":26691,"src_start":26133},{"artifact":0,"gen_end":84853,"gen_start":84411,"node":63,"role":"declaration","source":0,"src_end":27266,"src_start":26693},{"artifact":0,"gen_end":85312,"gen_start":84853,"node":64,"role":"declaration","source":0,"src_end":27837,"src_start":27268},{"artifact":0,"gen_end":85773,"gen_start":85312,"node":65,"role":"declaration","source":0,"src_end":28410,"src_start":27839},{"artifact":0,"gen_end":86248,"gen_start":85773,"node":66,"role":"declaration","source":0,"src_end":28997,"src_start":28412},{"artifact":0,"gen_end":86668,"gen_start":86248,"node":67,"role":"declaration","source":0,"src_end":29505,"src_start":28999},{"artifact":0,"gen_end":87104,"gen_start":86668,"node":68,"role":"declaration","source":0,"src_end":30029,"src_start":29507},{"artifact":0,"gen_end":87124,"gen_start":87104,"node":0,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":69,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":1,"gen_end":507,"gen_start":134,"node":70,"role":"declaration","source":0,"src_end":460,"src_start":234},{"artifact":1,"gen_end":791,"gen_start":507,"node":71,"role":"declaration","source":0,"src_end":626,"src_start":462},{"artifact":1,"gen_end":1329,"gen_start":791,"node":72,"role":"declaration","source":0,"src_end":830,"src_start":628},{"artifact":1,"gen_end":1624,"gen_start":1329,"node":73,"role":"declaration","source":0,"src_end":1068,"src_start":832},{"artifact":1,"gen_end":2298,"gen_start":1624,"node":74,"role":"declaration","source":0,"src_end":1290,"src_start":1070},{"artifact":1,"gen_end":2765,"gen_start":2298,"node":75,"role":"declaration","source":0,"src_end":1441,"src_start":1292},{"artifact":1,"gen_end":3101,"gen_start":2765,"node":76,"role":"declaration","source":0,"src_end":1592,"src_start":1443},{"artifact":1,"gen_end":3516,"gen_start":3101,"node":77,"role":"declaration","source":0,"src_end":1776,"src_start":1594},{"artifact":1,"gen_end":3835,"gen_start":3516,"node":78,"role":"declaration","source":0,"src_end":2078,"src_start":1778},{"artifact":1,"gen_end":4543,"gen_start":3835,"node":79,"role":"declaration","source":0,"src_end":2305,"src_start":2080},{"artifact":1,"gen_end":4993,"gen_start":4543,"node":80,"role":"declaration","source":0,"src_end":2682,"src_start":2307},{"artifact":1,"gen_end":5428,"gen_start":4993,"node":81,"role":"declaration","source":0,"src_end":3041,"src_start":2684},{"artifact":1,"gen_end":5934,"gen_start":5428,"node":82,"role":"declaration","source":0,"src_end":3345,"src_start":3043},{"artifact":1,"gen_end":6370,"gen_start":5934,"node":83,"role":"declaration","source":0,"src_end":3765,"src_start":3347},{"artifact":1,"gen_end":6770,"gen_start":6370,"node":84,"role":"declaration","source":0,"src_end":4281,"src_start":3767},{"artifact":1,"gen_end":7167,"gen_start":6770,"node":85,"role":"declaration","source":0,"src_end":4695,"src_start":4283},{"artifact":1,"gen_end":27214,"gen_start":7167,"node":86,"role":"declaration","source":0,"src_end":5734,"src_start":4697},{"artifact":1,"gen_end":27484,"gen_start":27214,"node":87,"role":"declaration","source":0,"src_end":5833,"src_start":5736},{"artifact":1,"gen_end":27833,"gen_start":27484,"node":88,"role":"declaration","source":0,"src_end":5968,"src_start":5835},{"artifact":1,"gen_end":28122,"gen_start":27833,"node":89,"role":"declaration","source":0,"src_end":6190,"src_start":5970},{"artifact":1,"gen_end":28806,"gen_start":28122,"node":90,"role":"declaration","source":0,"src_end":6389,"src_start":6192},{"artifact":1,"gen_end":29234,"gen_start":28806,"node":91,"role":"declaration","source":0,"src_end":6731,"src_start":6391},{"artifact":1,"gen_end":45911,"gen_start":29234,"node":92,"role":"declaration","source":0,"src_end":7608,"src_start":6733},{"artifact":1,"gen_end":46717,"gen_start":45911,"node":93,"role":"declaration","source":0,"src_end":8192,"src_start":7610},{"artifact":1,"gen_end":47505,"gen_start":46717,"node":94,"role":"declaration","source":0,"src_end":8767,"src_start":8194},{"artifact":1,"gen_end":48358,"gen_start":47505,"node":95,"role":"declaration","source":0,"src_end":9391,"src_start":8769},{"artifact":1,"gen_end":48897,"gen_start":48358,"node":96,"role":"declaration","source":0,"src_end":9707,"src_start":9393},{"artifact":1,"gen_end":49414,"gen_start":48897,"node":97,"role":"declaration","source":0,"src_end":9979,"src_start":9709},{"artifact":1,"gen_end":50201,"gen_start":49414,"node":98,"role":"declaration","source":0,"src_end":10553,"src_start":9981},{"artifact":1,"gen_end":50721,"gen_start":50201,"node":99,"role":"declaration","source":0,"src_end":10828,"src_start":10555},{"artifact":1,"gen_end":51247,"gen_start":50721,"node":100,"role":"declaration","source":0,"src_end":11117,"src_start":10830},{"artifact":1,"gen_end":52060,"gen_start":51247,"node":101,"role":"declaration","source":0,"src_end":11892,"src_start":11119},{"artifact":1,"gen_end":52262,"gen_start":52060,"node":102,"role":"declaration","source":0,"src_end":12020,"src_start":11894},{"artifact":1,"gen_end":53085,"gen_start":52262,"node":103,"role":"declaration","source":0,"src_end":12754,"src_start":12022},{"artifact":1,"gen_end":53450,"gen_start":53085,"node":104,"role":"declaration","source":0,"src_end":13058,"src_start":12756},{"artifact":1,"gen_end":53835,"gen_start":53450,"node":105,"role":"declaration","source":0,"src_end":13405,"src_start":13060},{"artifact":1,"gen_end":54301,"gen_start":53835,"node":106,"role":"declaration","source":0,"src_end":13816,"src_start":13407},{"artifact":1,"gen_end":54722,"gen_start":54301,"node":107,"role":"declaration","source":0,"src_end":14166,"src_start":13818},{"artifact":1,"gen_end":55103,"gen_start":54722,"node":108,"role":"declaration","source":0,"src_end":14502,"src_start":14168},{"artifact":1,"gen_end":55482,"gen_start":55103,"node":109,"role":"declaration","source":0,"src_end":14836,"src_start":14504},{"artifact":1,"gen_end":55686,"gen_start":55482,"node":110,"role":"declaration","source":0,"src_end":14966,"src_start":14838},{"artifact":1,"gen_end":56103,"gen_start":55686,"node":111,"role":"declaration","source":0,"src_end":15380,"src_start":14968},{"artifact":1,"gen_end":56312,"gen_start":56103,"node":112,"role":"declaration","source":0,"src_end":15545,"src_start":15382},{"artifact":1,"gen_end":56549,"gen_start":56312,"node":113,"role":"declaration","source":0,"src_end":15745,"src_start":15547},{"artifact":1,"gen_end":56887,"gen_start":56549,"node":114,"role":"declaration","source":0,"src_end":16068,"src_start":15747},{"artifact":1,"gen_end":57132,"gen_start":56887,"node":115,"role":"declaration","source":0,"src_end":16294,"src_start":16070},{"artifact":1,"gen_end":57358,"gen_start":57132,"node":116,"role":"declaration","source":0,"src_end":16477,"src_start":16296},{"artifact":1,"gen_end":57661,"gen_start":57358,"node":117,"role":"declaration","source":0,"src_end":16751,"src_start":16479},{"artifact":1,"gen_end":57861,"gen_start":57661,"node":118,"role":"declaration","source":0,"src_end":16877,"src_start":16753},{"artifact":1,"gen_end":58158,"gen_start":57861,"node":119,"role":"declaration","source":0,"src_end":17143,"src_start":16879},{"artifact":1,"gen_end":58398,"gen_start":58158,"node":120,"role":"declaration","source":0,"src_end":17346,"src_start":17145},{"artifact":1,"gen_end":58642,"gen_start":58398,"node":121,"role":"declaration","source":0,"src_end":17553,"src_start":17348},{"artifact":1,"gen_end":59987,"gen_start":58642,"node":122,"role":"declaration","source":0,"src_end":18780,"src_start":17555},{"artifact":1,"gen_end":61329,"gen_start":59987,"node":123,"role":"declaration","source":0,"src_end":20003,"src_start":18782},{"artifact":1,"gen_end":62672,"gen_start":61329,"node":124,"role":"declaration","source":0,"src_end":21228,"src_start":20005},{"artifact":1,"gen_end":63908,"gen_start":62672,"node":125,"role":"declaration","source":0,"src_end":22400,"src_start":21230},{"artifact":1,"gen_end":65141,"gen_start":63908,"node":126,"role":"declaration","source":0,"src_end":23568,"src_start":22402},{"artifact":1,"gen_end":66494,"gen_start":65141,"node":127,"role":"declaration","source":0,"src_end":24802,"src_start":23570},{"artifact":1,"gen_end":67043,"gen_start":66494,"node":128,"role":"declaration","source":0,"src_end":25281,"src_start":24804},{"artifact":1,"gen_end":67533,"gen_start":67043,"node":129,"role":"declaration","source":0,"src_end":25701,"src_start":25283},{"artifact":1,"gen_end":68034,"gen_start":67533,"node":130,"role":"declaration","source":0,"src_end":26131,"src_start":25703},{"artifact":1,"gen_end":68582,"gen_start":68034,"node":131,"role":"declaration","source":0,"src_end":26691,"src_start":26133},{"artifact":1,"gen_end":69146,"gen_start":68582,"node":132,"role":"declaration","source":0,"src_end":27266,"src_start":26693},{"artifact":1,"gen_end":69715,"gen_start":69146,"node":133,"role":"declaration","source":0,"src_end":27837,"src_start":27268},{"artifact":1,"gen_end":70287,"gen_start":69715,"node":134,"role":"declaration","source":0,"src_end":28410,"src_start":27839},{"artifact":1,"gen_end":70873,"gen_start":70287,"node":135,"role":"declaration","source":0,"src_end":28997,"src_start":28412},{"artifact":1,"gen_end":71403,"gen_start":70873,"node":136,"role":"declaration","source":0,"src_end":29505,"src_start":28999},{"artifact":1,"gen_end":71950,"gen_start":71403,"node":137,"role":"declaration","source":0,"src_end":30029,"src_start":29507},{"artifact":1,"gen_end":71965,"gen_start":71950,"node":69,"role":"declaration","source":0,"src_end":30065,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-latex-module"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"}],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"1c528893e116cb6b0cf1f39acb17a02c4e3e5302c5c8e2c802bb3cff19582468"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Main.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Main.tex"}],"mappings":[{"artifact":0,"gen_end":513,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":0,"gen_end":715,"gen_start":513,"node":1,"role":"declaration","source":0,"src_end":460,"src_start":234},{"artifact":0,"gen_end":716,"gen_start":715,"node":2,"role":"declaration","source":0,"src_end":626,"src_start":462},{"artifact":0,"gen_end":855,"gen_start":716,"node":3,"role":"declaration","source":0,"src_end":830,"src_start":628},{"artifact":0,"gen_end":1007,"gen_start":855,"node":4,"role":"declaration","source":0,"src_end":1068,"src_start":832},{"artifact":0,"gen_end":1177,"gen_start":1007,"node":5,"role":"declaration","source":0,"src_end":1290,"src_start":1070},{"artifact":0,"gen_end":1324,"gen_start":1177,"node":6,"role":"declaration","source":0,"src_end":1441,"src_start":1292},{"artifact":0,"gen_end":1474,"gen_start":1324,"node":7,"role":"declaration","source":0,"src_end":1592,"src_start":1443},{"artifact":0,"gen_end":1640,"gen_start":1474,"node":8,"role":"declaration","source":0,"src_end":1776,"src_start":1594},{"artifact":0,"gen_end":4775,"gen_start":1640,"node":9,"role":"declaration","source":0,"src_end":2078,"src_start":1778},{"artifact":0,"gen_end":4920,"gen_start":4775,"node":10,"role":"declaration","source":0,"src_end":2305,"src_start":2080},{"artifact":0,"gen_end":5224,"gen_start":4920,"node":11,"role":"declaration","source":0,"src_end":2682,"src_start":2307},{"artifact":0,"gen_end":5528,"gen_start":5224,"node":12,"role":"declaration","source":0,"src_end":3041,"src_start":2684},{"artifact":0,"gen_end":5818,"gen_start":5528,"node":13,"role":"declaration","source":0,"src_end":3345,"src_start":3043},{"artifact":0,"gen_end":9083,"gen_start":5818,"node":14,"role":"declaration","source":0,"src_end":3765,"src_start":3347},{"artifact":0,"gen_end":12456,"gen_start":9083,"node":15,"role":"declaration","source":0,"src_end":4281,"src_start":3767},{"artifact":0,"gen_end":15692,"gen_start":12456,"node":16,"role":"declaration","source":0,"src_end":4695,"src_start":4283},{"artifact":0,"gen_end":40686,"gen_start":15692,"node":17,"role":"declaration","source":0,"src_end":5734,"src_start":4697},{"artifact":0,"gen_end":40786,"gen_start":40686,"node":18,"role":"declaration","source":0,"src_end":5833,"src_start":5736},{"artifact":0,"gen_end":40889,"gen_start":40786,"node":19,"role":"declaration","source":0,"src_end":5968,"src_start":5835},{"artifact":0,"gen_end":43964,"gen_start":40889,"node":20,"role":"declaration","source":0,"src_end":6190,"src_start":5970},{"artifact":0,"gen_end":44111,"gen_start":43964,"node":21,"role":"declaration","source":0,"src_end":6389,"src_start":6192},{"artifact":0,"gen_end":47300,"gen_start":44111,"node":22,"role":"declaration","source":0,"src_end":6731,"src_start":6391},{"artifact":0,"gen_end":68181,"gen_start":47300,"node":23,"role":"declaration","source":0,"src_end":7608,"src_start":6733},{"artifact":0,"gen_end":68627,"gen_start":68181,"node":24,"role":"declaration","source":0,"src_end":8192,"src_start":7610},{"artifact":0,"gen_end":69055,"gen_start":68627,"node":25,"role":"declaration","source":0,"src_end":8767,"src_start":8194},{"artifact":0,"gen_end":69537,"gen_start":69055,"node":26,"role":"declaration","source":0,"src_end":9391,"src_start":8769},{"artifact":0,"gen_end":69696,"gen_start":69537,"node":27,"role":"declaration","source":0,"src_end":9707,"src_start":9393},{"artifact":0,"gen_end":69844,"gen_start":69696,"node":28,"role":"declaration","source":0,"src_end":9979,"src_start":9709},{"artifact":0,"gen_end":70271,"gen_start":69844,"node":29,"role":"declaration","source":0,"src_end":10553,"src_start":9981},{"artifact":0,"gen_end":70422,"gen_start":70271,"node":30,"role":"declaration","source":0,"src_end":10828,"src_start":10555},{"artifact":0,"gen_end":70579,"gen_start":70422,"node":31,"role":"declaration","source":0,"src_end":11117,"src_start":10830},{"artifact":0,"gen_end":71280,"gen_start":70579,"node":32,"role":"declaration","source":0,"src_end":11892,"src_start":11119},{"artifact":0,"gen_end":71372,"gen_start":71280,"node":33,"role":"declaration","source":0,"src_end":12020,"src_start":11894},{"artifact":0,"gen_end":72083,"gen_start":71372,"node":34,"role":"declaration","source":0,"src_end":12754,"src_start":12022},{"artifact":0,"gen_end":72336,"gen_start":72083,"node":35,"role":"declaration","source":0,"src_end":13058,"src_start":12756},{"artifact":0,"gen_end":72609,"gen_start":72336,"node":36,"role":"declaration","source":0,"src_end":13405,"src_start":13060},{"artifact":0,"gen_end":72964,"gen_start":72609,"node":37,"role":"declaration","source":0,"src_end":13816,"src_start":13407},{"artifact":0,"gen_end":73273,"gen_start":72964,"node":38,"role":"declaration","source":0,"src_end":14166,"src_start":13818},{"artifact":0,"gen_end":73549,"gen_start":73273,"node":39,"role":"declaration","source":0,"src_end":14502,"src_start":14168},{"artifact":0,"gen_end":73823,"gen_start":73549,"node":40,"role":"declaration","source":0,"src_end":14836,"src_start":14504},{"artifact":0,"gen_end":73917,"gen_start":73823,"node":41,"role":"declaration","source":0,"src_end":14966,"src_start":14838},{"artifact":0,"gen_end":74224,"gen_start":73917,"node":42,"role":"declaration","source":0,"src_end":15380,"src_start":14968},{"artifact":0,"gen_end":74323,"gen_start":74224,"node":43,"role":"declaration","source":0,"src_end":15545,"src_start":15382},{"artifact":0,"gen_end":74457,"gen_start":74323,"node":44,"role":"declaration","source":0,"src_end":15745,"src_start":15547},{"artifact":0,"gen_end":74674,"gen_start":74457,"node":45,"role":"declaration","source":0,"src_end":16068,"src_start":15747},{"artifact":0,"gen_end":74805,"gen_start":74674,"node":46,"role":"declaration","source":0,"src_end":16294,"src_start":16070},{"artifact":0,"gen_end":74910,"gen_start":74805,"node":47,"role":"declaration","source":0,"src_end":16477,"src_start":16296},{"artifact":0,"gen_end":75103,"gen_start":74910,"node":48,"role":"declaration","source":0,"src_end":16751,"src_start":16479},{"artifact":0,"gen_end":75193,"gen_start":75103,"node":49,"role":"declaration","source":0,"src_end":16877,"src_start":16753},{"artifact":0,"gen_end":75380,"gen_start":75193,"node":50,"role":"declaration","source":0,"src_end":17143,"src_start":16879},{"artifact":0,"gen_end":75517,"gen_start":75380,"node":51,"role":"declaration","source":0,"src_end":17346,"src_start":17145},{"artifact":0,"gen_end":75658,"gen_start":75517,"node":52,"role":"declaration","source":0,"src_end":17553,"src_start":17348},{"artifact":0,"gen_end":76881,"gen_start":75658,"node":53,"role":"declaration","source":0,"src_end":18780,"src_start":17555},{"artifact":0,"gen_end":78100,"gen_start":76881,"node":54,"role":"declaration","source":0,"src_end":20003,"src_start":18782},{"artifact":0,"gen_end":79321,"gen_start":78100,"node":55,"role":"declaration","source":0,"src_end":21228,"src_start":20005},{"artifact":0,"gen_end":80435,"gen_start":79321,"node":56,"role":"declaration","source":0,"src_end":22400,"src_start":21230},{"artifact":0,"gen_end":81545,"gen_start":80435,"node":57,"role":"declaration","source":0,"src_end":23568,"src_start":22402},{"artifact":0,"gen_end":82775,"gen_start":81545,"node":58,"role":"declaration","source":0,"src_end":24802,"src_start":23570},{"artifact":0,"gen_end":83214,"gen_start":82775,"node":59,"role":"declaration","source":0,"src_end":25281,"src_start":24804},{"artifact":0,"gen_end":83594,"gen_start":83214,"node":60,"role":"declaration","source":0,"src_end":25701,"src_start":25283},{"artifact":0,"gen_end":83984,"gen_start":83594,"node":61,"role":"declaration","source":0,"src_end":26131,"src_start":25703},{"artifact":0,"gen_end":84411,"gen_start":83984,"node":62,"role":"declaration","source":0,"src_end":26691,"src_start":26133},{"artifact":0,"gen_end":84853,"gen_start":84411,"node":63,"role":"declaration","source":0,"src_end":27266,"src_start":26693},{"artifact":0,"gen_end":85312,"gen_start":84853,"node":64,"role":"declaration","source":0,"src_end":27837,"src_start":27268},{"artifact":0,"gen_end":85773,"gen_start":85312,"node":65,"role":"declaration","source":0,"src_end":28410,"src_start":27839},{"artifact":0,"gen_end":86248,"gen_start":85773,"node":66,"role":"declaration","source":0,"src_end":28997,"src_start":28412},{"artifact":0,"gen_end":86668,"gen_start":86248,"node":67,"role":"declaration","source":0,"src_end":29505,"src_start":28999},{"artifact":0,"gen_end":87104,"gen_start":86668,"node":68,"role":"declaration","source":0,"src_end":30029,"src_start":29507},{"artifact":0,"gen_end":87124,"gen_start":87104,"node":0,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":69,"role":"declaration","source":0,"src_end":30065,"src_start":0},{"artifact":1,"gen_end":507,"gen_start":134,"node":70,"role":"declaration","source":0,"src_end":460,"src_start":234},{"artifact":1,"gen_end":791,"gen_start":507,"node":71,"role":"declaration","source":0,"src_end":626,"src_start":462},{"artifact":1,"gen_end":1329,"gen_start":791,"node":72,"role":"declaration","source":0,"src_end":830,"src_start":628},{"artifact":1,"gen_end":1624,"gen_start":1329,"node":73,"role":"declaration","source":0,"src_end":1068,"src_start":832},{"artifact":1,"gen_end":2298,"gen_start":1624,"node":74,"role":"declaration","source":0,"src_end":1290,"src_start":1070},{"artifact":1,"gen_end":2765,"gen_start":2298,"node":75,"role":"declaration","source":0,"src_end":1441,"src_start":1292},{"artifact":1,"gen_end":3101,"gen_start":2765,"node":76,"role":"declaration","source":0,"src_end":1592,"src_start":1443},{"artifact":1,"gen_end":3516,"gen_start":3101,"node":77,"role":"declaration","source":0,"src_end":1776,"src_start":1594},{"artifact":1,"gen_end":3835,"gen_start":3516,"node":78,"role":"declaration","source":0,"src_end":2078,"src_start":1778},{"artifact":1,"gen_end":4543,"gen_start":3835,"node":79,"role":"declaration","source":0,"src_end":2305,"src_start":2080},{"artifact":1,"gen_end":4993,"gen_start":4543,"node":80,"role":"declaration","source":0,"src_end":2682,"src_start":2307},{"artifact":1,"gen_end":5428,"gen_start":4993,"node":81,"role":"declaration","source":0,"src_end":3041,"src_start":2684},{"artifact":1,"gen_end":5934,"gen_start":5428,"node":82,"role":"declaration","source":0,"src_end":3345,"src_start":3043},{"artifact":1,"gen_end":6370,"gen_start":5934,"node":83,"role":"declaration","source":0,"src_end":3765,"src_start":3347},{"artifact":1,"gen_end":6770,"gen_start":6370,"node":84,"role":"declaration","source":0,"src_end":4281,"src_start":3767},{"artifact":1,"gen_end":7167,"gen_start":6770,"node":85,"role":"declaration","source":0,"src_end":4695,"src_start":4283},{"artifact":1,"gen_end":27214,"gen_start":7167,"node":86,"role":"declaration","source":0,"src_end":5734,"src_start":4697},{"artifact":1,"gen_end":27484,"gen_start":27214,"node":87,"role":"declaration","source":0,"src_end":5833,"src_start":5736},{"artifact":1,"gen_end":27833,"gen_start":27484,"node":88,"role":"declaration","source":0,"src_end":5968,"src_start":5835},{"artifact":1,"gen_end":28122,"gen_start":27833,"node":89,"role":"declaration","source":0,"src_end":6190,"src_start":5970},{"artifact":1,"gen_end":28806,"gen_start":28122,"node":90,"role":"declaration","source":0,"src_end":6389,"src_start":6192},{"artifact":1,"gen_end":29234,"gen_start":28806,"node":91,"role":"declaration","source":0,"src_end":6731,"src_start":6391},{"artifact":1,"gen_end":45911,"gen_start":29234,"node":92,"role":"declaration","source":0,"src_end":7608,"src_start":6733},{"artifact":1,"gen_end":46717,"gen_start":45911,"node":93,"role":"declaration","source":0,"src_end":8192,"src_start":7610},{"artifact":1,"gen_end":47505,"gen_start":46717,"node":94,"role":"declaration","source":0,"src_end":8767,"src_start":8194},{"artifact":1,"gen_end":48358,"gen_start":47505,"node":95,"role":"declaration","source":0,"src_end":9391,"src_start":8769},{"artifact":1,"gen_end":48897,"gen_start":48358,"node":96,"role":"declaration","source":0,"src_end":9707,"src_start":9393},{"artifact":1,"gen_end":49414,"gen_start":48897,"node":97,"role":"declaration","source":0,"src_end":9979,"src_start":9709},{"artifact":1,"gen_end":50201,"gen_start":49414,"node":98,"role":"declaration","source":0,"src_end":10553,"src_start":9981},{"artifact":1,"gen_end":50721,"gen_start":50201,"node":99,"role":"declaration","source":0,"src_end":10828,"src_start":10555},{"artifact":1,"gen_end":51247,"gen_start":50721,"node":100,"role":"declaration","source":0,"src_end":11117,"src_start":10830},{"artifact":1,"gen_end":52060,"gen_start":51247,"node":101,"role":"declaration","source":0,"src_end":11892,"src_start":11119},{"artifact":1,"gen_end":52262,"gen_start":52060,"node":102,"role":"declaration","source":0,"src_end":12020,"src_start":11894},{"artifact":1,"gen_end":53085,"gen_start":52262,"node":103,"role":"declaration","source":0,"src_end":12754,"src_start":12022},{"artifact":1,"gen_end":53450,"gen_start":53085,"node":104,"role":"declaration","source":0,"src_end":13058,"src_start":12756},{"artifact":1,"gen_end":53835,"gen_start":53450,"node":105,"role":"declaration","source":0,"src_end":13405,"src_start":13060},{"artifact":1,"gen_end":54301,"gen_start":53835,"node":106,"role":"declaration","source":0,"src_end":13816,"src_start":13407},{"artifact":1,"gen_end":54722,"gen_start":54301,"node":107,"role":"declaration","source":0,"src_end":14166,"src_start":13818},{"artifact":1,"gen_end":55103,"gen_start":54722,"node":108,"role":"declaration","source":0,"src_end":14502,"src_start":14168},{"artifact":1,"gen_end":55482,"gen_start":55103,"node":109,"role":"declaration","source":0,"src_end":14836,"src_start":14504},{"artifact":1,"gen_end":55686,"gen_start":55482,"node":110,"role":"declaration","source":0,"src_end":14966,"src_start":14838},{"artifact":1,"gen_end":56103,"gen_start":55686,"node":111,"role":"declaration","source":0,"src_end":15380,"src_start":14968},{"artifact":1,"gen_end":56312,"gen_start":56103,"node":112,"role":"declaration","source":0,"src_end":15545,"src_start":15382},{"artifact":1,"gen_end":56549,"gen_start":56312,"node":113,"role":"declaration","source":0,"src_end":15745,"src_start":15547},{"artifact":1,"gen_end":56887,"gen_start":56549,"node":114,"role":"declaration","source":0,"src_end":16068,"src_start":15747},{"artifact":1,"gen_end":57132,"gen_start":56887,"node":115,"role":"declaration","source":0,"src_end":16294,"src_start":16070},{"artifact":1,"gen_end":57358,"gen_start":57132,"node":116,"role":"declaration","source":0,"src_end":16477,"src_start":16296},{"artifact":1,"gen_end":57661,"gen_start":57358,"node":117,"role":"declaration","source":0,"src_end":16751,"src_start":16479},{"artifact":1,"gen_end":57861,"gen_start":57661,"node":118,"role":"declaration","source":0,"src_end":16877,"src_start":16753},{"artifact":1,"gen_end":58158,"gen_start":57861,"node":119,"role":"declaration","source":0,"src_end":17143,"src_start":16879},{"artifact":1,"gen_end":58398,"gen_start":58158,"node":120,"role":"declaration","source":0,"src_end":17346,"src_start":17145},{"artifact":1,"gen_end":58642,"gen_start":58398,"node":121,"role":"declaration","source":0,"src_end":17553,"src_start":17348},{"artifact":1,"gen_end":59987,"gen_start":58642,"node":122,"role":"declaration","source":0,"src_end":18780,"src_start":17555},{"artifact":1,"gen_end":61329,"gen_start":59987,"node":123,"role":"declaration","source":0,"src_end":20003,"src_start":18782},{"artifact":1,"gen_end":62672,"gen_start":61329,"node":124,"role":"declaration","source":0,"src_end":21228,"src_start":20005},{"artifact":1,"gen_end":63908,"gen_start":62672,"node":125,"role":"declaration","source":0,"src_end":22400,"src_start":21230},{"artifact":1,"gen_end":65141,"gen_start":63908,"node":126,"role":"declaration","source":0,"src_end":23568,"src_start":22402},{"artifact":1,"gen_end":66494,"gen_start":65141,"node":127,"role":"declaration","source":0,"src_end":24802,"src_start":23570},{"artifact":1,"gen_end":67043,"gen_start":66494,"node":128,"role":"declaration","source":0,"src_end":25281,"src_start":24804},{"artifact":1,"gen_end":67533,"gen_start":67043,"node":129,"role":"declaration","source":0,"src_end":25701,"src_start":25283},{"artifact":1,"gen_end":68034,"gen_start":67533,"node":130,"role":"declaration","source":0,"src_end":26131,"src_start":25703},{"artifact":1,"gen_end":68582,"gen_start":68034,"node":131,"role":"declaration","source":0,"src_end":26691,"src_start":26133},{"artifact":1,"gen_end":69146,"gen_start":68582,"node":132,"role":"declaration","source":0,"src_end":27266,"src_start":26693},{"artifact":1,"gen_end":69715,"gen_start":69146,"node":133,"role":"declaration","source":0,"src_end":27837,"src_start":27268},{"artifact":1,"gen_end":70287,"gen_start":69715,"node":134,"role":"declaration","source":0,"src_end":28410,"src_start":27839},{"artifact":1,"gen_end":70873,"gen_start":70287,"node":135,"role":"declaration","source":0,"src_end":28997,"src_start":28412},{"artifact":1,"gen_end":71403,"gen_start":70873,"node":136,"role":"declaration","source":0,"src_end":29505,"src_start":28999},{"artifact":1,"gen_end":71950,"gen_start":71403,"node":137,"role":"declaration","source":0,"src_end":30029,"src_start":29507},{"artifact":1,"gen_end":71965,"gen_start":71950,"node":69,"role":"declaration","source":0,"src_end":30065,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-latex-module"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"},{"id":128,"kind":"semantic-declaration"},{"id":129,"kind":"semantic-declaration"},{"id":130,"kind":"semantic-declaration"},{"id":131,"kind":"semantic-declaration"},{"id":132,"kind":"semantic-declaration"},{"id":133,"kind":"semantic-declaration"},{"id":134,"kind":"semantic-declaration"},{"id":135,"kind":"semantic-declaration"},{"id":136,"kind":"semantic-declaration"},{"id":137,"kind":"semantic-declaration"}],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"1c528893e116cb6b0cf1f39acb17a02c4e3e5302c5c8e2c802bb3cff19582468"}],"spec":"lexlean/source-map/1"} diff --git a/examples/reasoning/expected/build/maps/Reasoning/Planner.map.json b/examples/reasoning/expected/build/maps/Reasoning/Planner.map.json index 3809c18ca..16971cf8f 100644 --- a/examples/reasoning/expected/build/maps/Reasoning/Planner.map.json +++ b/examples/reasoning/expected/build/maps/Reasoning/Planner.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Planner.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Planner.tex"}],"mappings":[{"artifact":0,"gen_end":352,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":0,"gen_end":483,"gen_start":352,"node":1,"role":"declaration","source":0,"src_end":284,"src_start":142},{"artifact":0,"gen_end":587,"gen_start":483,"node":2,"role":"declaration","source":0,"src_end":410,"src_start":286},{"artifact":0,"gen_end":3654,"gen_start":587,"node":3,"role":"declaration","source":0,"src_end":600,"src_start":412},{"artifact":0,"gen_end":3807,"gen_start":3654,"node":4,"role":"declaration","source":0,"src_end":747,"src_start":602},{"artifact":0,"gen_end":6889,"gen_start":3807,"node":5,"role":"declaration","source":0,"src_end":1008,"src_start":749},{"artifact":0,"gen_end":7675,"gen_start":6889,"node":6,"role":"declaration","source":0,"src_end":1248,"src_start":1010},{"artifact":0,"gen_end":10758,"gen_start":7675,"node":7,"role":"declaration","source":0,"src_end":1509,"src_start":1250},{"artifact":0,"gen_end":11554,"gen_start":10758,"node":8,"role":"declaration","source":0,"src_end":1750,"src_start":1511},{"artifact":0,"gen_end":14726,"gen_start":11554,"node":9,"role":"declaration","source":0,"src_end":2087,"src_start":1752},{"artifact":0,"gen_end":15765,"gen_start":14726,"node":10,"role":"declaration","source":0,"src_end":2476,"src_start":2089},{"artifact":0,"gen_end":15892,"gen_start":15765,"node":11,"role":"declaration","source":0,"src_end":2624,"src_start":2478},{"artifact":0,"gen_end":16032,"gen_start":15892,"node":12,"role":"declaration","source":0,"src_end":2799,"src_start":2626},{"artifact":0,"gen_end":19127,"gen_start":16032,"node":13,"role":"declaration","source":0,"src_end":3043,"src_start":2801},{"artifact":0,"gen_end":19290,"gen_start":19127,"node":14,"role":"declaration","source":0,"src_end":3251,"src_start":3045},{"artifact":0,"gen_end":22293,"gen_start":19290,"node":15,"role":"declaration","source":0,"src_end":3444,"src_start":3253},{"artifact":0,"gen_end":49981,"gen_start":22293,"node":16,"role":"declaration","source":0,"src_end":4017,"src_start":3446},{"artifact":0,"gen_end":50066,"gen_start":49981,"node":17,"role":"declaration","source":0,"src_end":4110,"src_start":4019},{"artifact":0,"gen_end":50154,"gen_start":50066,"node":18,"role":"declaration","source":0,"src_end":4239,"src_start":4112},{"artifact":0,"gen_end":53224,"gen_start":50154,"node":19,"role":"declaration","source":0,"src_end":4465,"src_start":4241},{"artifact":0,"gen_end":53379,"gen_start":53224,"node":20,"role":"declaration","source":0,"src_end":4657,"src_start":4467},{"artifact":0,"gen_end":53463,"gen_start":53379,"node":21,"role":"declaration","source":0,"src_end":4749,"src_start":4659},{"artifact":0,"gen_end":53550,"gen_start":53463,"node":22,"role":"declaration","source":0,"src_end":4877,"src_start":4751},{"artifact":0,"gen_end":56615,"gen_start":53550,"node":23,"role":"declaration","source":0,"src_end":5098,"src_start":4879},{"artifact":0,"gen_end":56769,"gen_start":56615,"node":24,"role":"declaration","source":0,"src_end":5289,"src_start":5100},{"artifact":0,"gen_end":59881,"gen_start":56769,"node":25,"role":"declaration","source":0,"src_end":5589,"src_start":5291},{"artifact":0,"gen_end":60019,"gen_start":59881,"node":26,"role":"declaration","source":0,"src_end":5743,"src_start":5591},{"artifact":0,"gen_end":63034,"gen_start":60019,"node":27,"role":"declaration","source":0,"src_end":5947,"src_start":5745},{"artifact":0,"gen_end":66145,"gen_start":63034,"node":28,"role":"declaration","source":0,"src_end":6227,"src_start":5949},{"artifact":0,"gen_end":69273,"gen_start":66145,"node":29,"role":"declaration","source":0,"src_end":6541,"src_start":6229},{"artifact":0,"gen_end":72365,"gen_start":69273,"node":30,"role":"declaration","source":0,"src_end":6821,"src_start":6543},{"artifact":0,"gen_end":100730,"gen_start":72365,"node":31,"role":"declaration","source":0,"src_end":7430,"src_start":6823},{"artifact":0,"gen_end":130090,"gen_start":100730,"node":32,"role":"declaration","source":0,"src_end":8099,"src_start":7432},{"artifact":0,"gen_end":158714,"gen_start":130090,"node":33,"role":"declaration","source":0,"src_end":8669,"src_start":8101},{"artifact":0,"gen_end":158737,"gen_start":158714,"node":0,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":34,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":1,"gen_end":450,"gen_start":134,"node":35,"role":"declaration","source":0,"src_end":284,"src_start":142},{"artifact":1,"gen_end":740,"gen_start":450,"node":36,"role":"declaration","source":0,"src_end":410,"src_start":286},{"artifact":1,"gen_end":1018,"gen_start":740,"node":37,"role":"declaration","source":0,"src_end":600,"src_start":412},{"artifact":1,"gen_end":1647,"gen_start":1018,"node":38,"role":"declaration","source":0,"src_end":747,"src_start":602},{"artifact":1,"gen_end":1989,"gen_start":1647,"node":39,"role":"declaration","source":0,"src_end":1008,"src_start":749},{"artifact":1,"gen_end":3308,"gen_start":1989,"node":40,"role":"declaration","source":0,"src_end":1248,"src_start":1010},{"artifact":1,"gen_end":3651,"gen_start":3308,"node":41,"role":"declaration","source":0,"src_end":1509,"src_start":1250},{"artifact":1,"gen_end":4981,"gen_start":3651,"node":42,"role":"declaration","source":0,"src_end":1750,"src_start":1511},{"artifact":1,"gen_end":5415,"gen_start":4981,"node":43,"role":"declaration","source":0,"src_end":2087,"src_start":1752},{"artifact":1,"gen_end":7272,"gen_start":5415,"node":44,"role":"declaration","source":0,"src_end":2476,"src_start":2089},{"artifact":1,"gen_end":7585,"gen_start":7272,"node":45,"role":"declaration","source":0,"src_end":2624,"src_start":2478},{"artifact":1,"gen_end":7974,"gen_start":7585,"node":46,"role":"declaration","source":0,"src_end":2799,"src_start":2626},{"artifact":1,"gen_end":8279,"gen_start":7974,"node":47,"role":"declaration","source":0,"src_end":3043,"src_start":2801},{"artifact":1,"gen_end":8992,"gen_start":8279,"node":48,"role":"declaration","source":0,"src_end":3251,"src_start":3045},{"artifact":1,"gen_end":9254,"gen_start":8992,"node":49,"role":"declaration","source":0,"src_end":3444,"src_start":3253},{"artifact":1,"gen_end":27419,"gen_start":9254,"node":50,"role":"declaration","source":0,"src_end":4017,"src_start":3446},{"artifact":1,"gen_end":27674,"gen_start":27419,"node":51,"role":"declaration","source":0,"src_end":4110,"src_start":4019},{"artifact":1,"gen_end":28008,"gen_start":27674,"node":52,"role":"declaration","source":0,"src_end":4239,"src_start":4112},{"artifact":1,"gen_end":28292,"gen_start":28008,"node":53,"role":"declaration","source":0,"src_end":4465,"src_start":4241},{"artifact":1,"gen_end":28953,"gen_start":28292,"node":54,"role":"declaration","source":0,"src_end":4657,"src_start":4467},{"artifact":1,"gen_end":29207,"gen_start":28953,"node":55,"role":"declaration","source":0,"src_end":4749,"src_start":4659},{"artifact":1,"gen_end":29540,"gen_start":29207,"node":56,"role":"declaration","source":0,"src_end":4877,"src_start":4751},{"artifact":1,"gen_end":29821,"gen_start":29540,"node":57,"role":"declaration","source":0,"src_end":5098,"src_start":4879},{"artifact":1,"gen_end":30480,"gen_start":29821,"node":58,"role":"declaration","source":0,"src_end":5289,"src_start":5100},{"artifact":1,"gen_end":30826,"gen_start":30480,"node":59,"role":"declaration","source":0,"src_end":5589,"src_start":5291},{"artifact":1,"gen_end":31150,"gen_start":30826,"node":60,"role":"declaration","source":0,"src_end":5743,"src_start":5591},{"artifact":1,"gen_end":31418,"gen_start":31150,"node":61,"role":"declaration","source":0,"src_end":5947,"src_start":5745},{"artifact":1,"gen_end":31775,"gen_start":31418,"node":62,"role":"declaration","source":0,"src_end":6227,"src_start":5949},{"artifact":1,"gen_end":32131,"gen_start":31775,"node":63,"role":"declaration","source":0,"src_end":6541,"src_start":6229},{"artifact":1,"gen_end":32464,"gen_start":32131,"node":64,"role":"declaration","source":0,"src_end":6821,"src_start":6543},{"artifact":1,"gen_end":51452,"gen_start":32464,"node":65,"role":"declaration","source":0,"src_end":7430,"src_start":6823},{"artifact":1,"gen_end":71336,"gen_start":51452,"node":66,"role":"declaration","source":0,"src_end":8099,"src_start":7432},{"artifact":1,"gen_end":90352,"gen_start":71336,"node":67,"role":"declaration","source":0,"src_end":8669,"src_start":8101},{"artifact":1,"gen_end":90367,"gen_start":90352,"node":34,"role":"declaration","source":0,"src_end":8705,"src_start":0}],"module":"Planner","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-latex-module"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"}],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","sources":[{"id":0,"kind":"file","path":"src/Planner.lex.tex","sha256":"8ebdbb36e0f5607e8ca0cdac698535bdd0fc793f9173ecc275817b706ec68f16"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Planner.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Planner.tex"}],"mappings":[{"artifact":0,"gen_end":352,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":0,"gen_end":483,"gen_start":352,"node":1,"role":"declaration","source":0,"src_end":284,"src_start":142},{"artifact":0,"gen_end":587,"gen_start":483,"node":2,"role":"declaration","source":0,"src_end":410,"src_start":286},{"artifact":0,"gen_end":3654,"gen_start":587,"node":3,"role":"declaration","source":0,"src_end":600,"src_start":412},{"artifact":0,"gen_end":3807,"gen_start":3654,"node":4,"role":"declaration","source":0,"src_end":747,"src_start":602},{"artifact":0,"gen_end":6889,"gen_start":3807,"node":5,"role":"declaration","source":0,"src_end":1008,"src_start":749},{"artifact":0,"gen_end":7675,"gen_start":6889,"node":6,"role":"declaration","source":0,"src_end":1248,"src_start":1010},{"artifact":0,"gen_end":10758,"gen_start":7675,"node":7,"role":"declaration","source":0,"src_end":1509,"src_start":1250},{"artifact":0,"gen_end":11554,"gen_start":10758,"node":8,"role":"declaration","source":0,"src_end":1750,"src_start":1511},{"artifact":0,"gen_end":14726,"gen_start":11554,"node":9,"role":"declaration","source":0,"src_end":2087,"src_start":1752},{"artifact":0,"gen_end":15765,"gen_start":14726,"node":10,"role":"declaration","source":0,"src_end":2476,"src_start":2089},{"artifact":0,"gen_end":15892,"gen_start":15765,"node":11,"role":"declaration","source":0,"src_end":2624,"src_start":2478},{"artifact":0,"gen_end":16032,"gen_start":15892,"node":12,"role":"declaration","source":0,"src_end":2799,"src_start":2626},{"artifact":0,"gen_end":19127,"gen_start":16032,"node":13,"role":"declaration","source":0,"src_end":3043,"src_start":2801},{"artifact":0,"gen_end":19290,"gen_start":19127,"node":14,"role":"declaration","source":0,"src_end":3251,"src_start":3045},{"artifact":0,"gen_end":22293,"gen_start":19290,"node":15,"role":"declaration","source":0,"src_end":3444,"src_start":3253},{"artifact":0,"gen_end":49981,"gen_start":22293,"node":16,"role":"declaration","source":0,"src_end":4017,"src_start":3446},{"artifact":0,"gen_end":50066,"gen_start":49981,"node":17,"role":"declaration","source":0,"src_end":4110,"src_start":4019},{"artifact":0,"gen_end":50154,"gen_start":50066,"node":18,"role":"declaration","source":0,"src_end":4239,"src_start":4112},{"artifact":0,"gen_end":53224,"gen_start":50154,"node":19,"role":"declaration","source":0,"src_end":4465,"src_start":4241},{"artifact":0,"gen_end":53379,"gen_start":53224,"node":20,"role":"declaration","source":0,"src_end":4657,"src_start":4467},{"artifact":0,"gen_end":53463,"gen_start":53379,"node":21,"role":"declaration","source":0,"src_end":4749,"src_start":4659},{"artifact":0,"gen_end":53550,"gen_start":53463,"node":22,"role":"declaration","source":0,"src_end":4877,"src_start":4751},{"artifact":0,"gen_end":56615,"gen_start":53550,"node":23,"role":"declaration","source":0,"src_end":5098,"src_start":4879},{"artifact":0,"gen_end":56769,"gen_start":56615,"node":24,"role":"declaration","source":0,"src_end":5289,"src_start":5100},{"artifact":0,"gen_end":59881,"gen_start":56769,"node":25,"role":"declaration","source":0,"src_end":5589,"src_start":5291},{"artifact":0,"gen_end":60019,"gen_start":59881,"node":26,"role":"declaration","source":0,"src_end":5743,"src_start":5591},{"artifact":0,"gen_end":63034,"gen_start":60019,"node":27,"role":"declaration","source":0,"src_end":5947,"src_start":5745},{"artifact":0,"gen_end":66145,"gen_start":63034,"node":28,"role":"declaration","source":0,"src_end":6227,"src_start":5949},{"artifact":0,"gen_end":69273,"gen_start":66145,"node":29,"role":"declaration","source":0,"src_end":6541,"src_start":6229},{"artifact":0,"gen_end":72365,"gen_start":69273,"node":30,"role":"declaration","source":0,"src_end":6821,"src_start":6543},{"artifact":0,"gen_end":100730,"gen_start":72365,"node":31,"role":"declaration","source":0,"src_end":7430,"src_start":6823},{"artifact":0,"gen_end":130090,"gen_start":100730,"node":32,"role":"declaration","source":0,"src_end":8099,"src_start":7432},{"artifact":0,"gen_end":158714,"gen_start":130090,"node":33,"role":"declaration","source":0,"src_end":8669,"src_start":8101},{"artifact":0,"gen_end":158737,"gen_start":158714,"node":0,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":34,"role":"declaration","source":0,"src_end":8705,"src_start":0},{"artifact":1,"gen_end":450,"gen_start":134,"node":35,"role":"declaration","source":0,"src_end":284,"src_start":142},{"artifact":1,"gen_end":740,"gen_start":450,"node":36,"role":"declaration","source":0,"src_end":410,"src_start":286},{"artifact":1,"gen_end":1018,"gen_start":740,"node":37,"role":"declaration","source":0,"src_end":600,"src_start":412},{"artifact":1,"gen_end":1647,"gen_start":1018,"node":38,"role":"declaration","source":0,"src_end":747,"src_start":602},{"artifact":1,"gen_end":1989,"gen_start":1647,"node":39,"role":"declaration","source":0,"src_end":1008,"src_start":749},{"artifact":1,"gen_end":3308,"gen_start":1989,"node":40,"role":"declaration","source":0,"src_end":1248,"src_start":1010},{"artifact":1,"gen_end":3651,"gen_start":3308,"node":41,"role":"declaration","source":0,"src_end":1509,"src_start":1250},{"artifact":1,"gen_end":4981,"gen_start":3651,"node":42,"role":"declaration","source":0,"src_end":1750,"src_start":1511},{"artifact":1,"gen_end":5415,"gen_start":4981,"node":43,"role":"declaration","source":0,"src_end":2087,"src_start":1752},{"artifact":1,"gen_end":7272,"gen_start":5415,"node":44,"role":"declaration","source":0,"src_end":2476,"src_start":2089},{"artifact":1,"gen_end":7585,"gen_start":7272,"node":45,"role":"declaration","source":0,"src_end":2624,"src_start":2478},{"artifact":1,"gen_end":7974,"gen_start":7585,"node":46,"role":"declaration","source":0,"src_end":2799,"src_start":2626},{"artifact":1,"gen_end":8279,"gen_start":7974,"node":47,"role":"declaration","source":0,"src_end":3043,"src_start":2801},{"artifact":1,"gen_end":8992,"gen_start":8279,"node":48,"role":"declaration","source":0,"src_end":3251,"src_start":3045},{"artifact":1,"gen_end":9254,"gen_start":8992,"node":49,"role":"declaration","source":0,"src_end":3444,"src_start":3253},{"artifact":1,"gen_end":27419,"gen_start":9254,"node":50,"role":"declaration","source":0,"src_end":4017,"src_start":3446},{"artifact":1,"gen_end":27674,"gen_start":27419,"node":51,"role":"declaration","source":0,"src_end":4110,"src_start":4019},{"artifact":1,"gen_end":28008,"gen_start":27674,"node":52,"role":"declaration","source":0,"src_end":4239,"src_start":4112},{"artifact":1,"gen_end":28292,"gen_start":28008,"node":53,"role":"declaration","source":0,"src_end":4465,"src_start":4241},{"artifact":1,"gen_end":28953,"gen_start":28292,"node":54,"role":"declaration","source":0,"src_end":4657,"src_start":4467},{"artifact":1,"gen_end":29207,"gen_start":28953,"node":55,"role":"declaration","source":0,"src_end":4749,"src_start":4659},{"artifact":1,"gen_end":29540,"gen_start":29207,"node":56,"role":"declaration","source":0,"src_end":4877,"src_start":4751},{"artifact":1,"gen_end":29821,"gen_start":29540,"node":57,"role":"declaration","source":0,"src_end":5098,"src_start":4879},{"artifact":1,"gen_end":30480,"gen_start":29821,"node":58,"role":"declaration","source":0,"src_end":5289,"src_start":5100},{"artifact":1,"gen_end":30826,"gen_start":30480,"node":59,"role":"declaration","source":0,"src_end":5589,"src_start":5291},{"artifact":1,"gen_end":31150,"gen_start":30826,"node":60,"role":"declaration","source":0,"src_end":5743,"src_start":5591},{"artifact":1,"gen_end":31418,"gen_start":31150,"node":61,"role":"declaration","source":0,"src_end":5947,"src_start":5745},{"artifact":1,"gen_end":31775,"gen_start":31418,"node":62,"role":"declaration","source":0,"src_end":6227,"src_start":5949},{"artifact":1,"gen_end":32131,"gen_start":31775,"node":63,"role":"declaration","source":0,"src_end":6541,"src_start":6229},{"artifact":1,"gen_end":32464,"gen_start":32131,"node":64,"role":"declaration","source":0,"src_end":6821,"src_start":6543},{"artifact":1,"gen_end":51452,"gen_start":32464,"node":65,"role":"declaration","source":0,"src_end":7430,"src_start":6823},{"artifact":1,"gen_end":71336,"gen_start":51452,"node":66,"role":"declaration","source":0,"src_end":8099,"src_start":7432},{"artifact":1,"gen_end":90352,"gen_start":71336,"node":67,"role":"declaration","source":0,"src_end":8669,"src_start":8101},{"artifact":1,"gen_end":90367,"gen_start":90352,"node":34,"role":"declaration","source":0,"src_end":8705,"src_start":0}],"module":"Planner","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-latex-module"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"}],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","sources":[{"id":0,"kind":"file","path":"src/Planner.lex.tex","sha256":"8ebdbb36e0f5607e8ca0cdac698535bdd0fc793f9173ecc275817b706ec68f16"}],"spec":"lexlean/source-map/1"} diff --git a/examples/reasoning/expected/build/maps/Reasoning/Screening.map.json b/examples/reasoning/expected/build/maps/Reasoning/Screening.map.json index f9b1f7204..caa85ae18 100644 --- a/examples/reasoning/expected/build/maps/Reasoning/Screening.map.json +++ b/examples/reasoning/expected/build/maps/Reasoning/Screening.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Screening.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Screening.tex"}],"mappings":[{"artifact":0,"gen_end":390,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":0,"gen_end":516,"gen_start":390,"node":1,"role":"declaration","source":0,"src_end":276,"src_start":146},{"artifact":0,"gen_end":645,"gen_start":516,"node":2,"role":"declaration","source":0,"src_end":434,"src_start":278},{"artifact":0,"gen_end":3714,"gen_start":645,"node":3,"role":"declaration","source":0,"src_end":659,"src_start":436},{"artifact":0,"gen_end":3886,"gen_start":3714,"node":4,"role":"declaration","source":0,"src_end":899,"src_start":661},{"artifact":0,"gen_end":4151,"gen_start":3886,"node":5,"role":"declaration","source":0,"src_end":1201,"src_start":901},{"artifact":0,"gen_end":4260,"gen_start":4151,"node":6,"role":"declaration","source":0,"src_end":1298,"src_start":1203},{"artifact":0,"gen_end":4412,"gen_start":4260,"node":7,"role":"declaration","source":0,"src_end":1473,"src_start":1300},{"artifact":0,"gen_end":4413,"gen_start":4412,"node":8,"role":"declaration","source":0,"src_end":1565,"src_start":1475},{"artifact":0,"gen_end":7509,"gen_start":4413,"node":9,"role":"declaration","source":0,"src_end":1803,"src_start":1567},{"artifact":0,"gen_end":8854,"gen_start":7509,"node":10,"role":"declaration","source":0,"src_end":2213,"src_start":1805},{"artifact":0,"gen_end":8937,"gen_start":8854,"node":11,"role":"declaration","source":0,"src_end":2305,"src_start":2215},{"artifact":0,"gen_end":9023,"gen_start":8937,"node":12,"role":"declaration","source":0,"src_end":2433,"src_start":2307},{"artifact":0,"gen_end":12068,"gen_start":9023,"node":13,"role":"declaration","source":0,"src_end":2634,"src_start":2435},{"artifact":0,"gen_end":12225,"gen_start":12068,"node":14,"role":"declaration","source":0,"src_end":2817,"src_start":2636},{"artifact":0,"gen_end":20447,"gen_start":12225,"node":15,"role":"declaration","source":0,"src_end":3166,"src_start":2819},{"artifact":0,"gen_end":42522,"gen_start":20447,"node":16,"role":"declaration","source":0,"src_end":3606,"src_start":3168},{"artifact":0,"gen_end":42547,"gen_start":42522,"node":0,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":276,"src_start":146},{"artifact":1,"gen_end":805,"gen_start":430,"node":19,"role":"declaration","source":0,"src_end":434,"src_start":278},{"artifact":1,"gen_end":1090,"gen_start":805,"node":20,"role":"declaration","source":0,"src_end":659,"src_start":436},{"artifact":1,"gen_end":1752,"gen_start":1090,"node":21,"role":"declaration","source":0,"src_end":899,"src_start":661},{"artifact":1,"gen_end":2542,"gen_start":1752,"node":22,"role":"declaration","source":0,"src_end":1201,"src_start":901},{"artifact":1,"gen_end":2959,"gen_start":2542,"node":23,"role":"declaration","source":0,"src_end":1298,"src_start":1203},{"artifact":1,"gen_end":3312,"gen_start":2959,"node":24,"role":"declaration","source":0,"src_end":1473,"src_start":1300},{"artifact":1,"gen_end":3527,"gen_start":3312,"node":25,"role":"declaration","source":0,"src_end":1565,"src_start":1475},{"artifact":1,"gen_end":3850,"gen_start":3527,"node":26,"role":"declaration","source":0,"src_end":1803,"src_start":1567},{"artifact":1,"gen_end":5867,"gen_start":3850,"node":27,"role":"declaration","source":0,"src_end":2213,"src_start":1805},{"artifact":1,"gen_end":6121,"gen_start":5867,"node":28,"role":"declaration","source":0,"src_end":2305,"src_start":2215},{"artifact":1,"gen_end":6454,"gen_start":6121,"node":29,"role":"declaration","source":0,"src_end":2433,"src_start":2307},{"artifact":1,"gen_end":6717,"gen_start":6454,"node":30,"role":"declaration","source":0,"src_end":2634,"src_start":2435},{"artifact":1,"gen_end":7348,"gen_start":6717,"node":31,"role":"declaration","source":0,"src_end":2817,"src_start":2636},{"artifact":1,"gen_end":13192,"gen_start":7348,"node":32,"role":"declaration","source":0,"src_end":3166,"src_start":2819},{"artifact":1,"gen_end":27179,"gen_start":13192,"node":33,"role":"declaration","source":0,"src_end":3606,"src_start":3168},{"artifact":1,"gen_end":27194,"gen_start":27179,"node":17,"role":"declaration","source":0,"src_end":3642,"src_start":0}],"module":"Screening","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"7b45b58d681c076cfd69727310b65f3fa63b0a50619281de2bf41504227f308d","source_id":"2d4bae2a2e1a68f05b8703a9e5c6ab1dc1a1bfbfe4e3d9885a7e842bcc0fad92","sources":[{"id":0,"kind":"file","path":"src/Screening.lex.tex","sha256":"3dc86d2c1968e2eee6b3f55e1013f2ad4506f81a29a261e767d7dd2029b77efc"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Reasoning/Screening.lean"},{"id":1,"kind":"tex","path":"modules/Reasoning/Screening.tex"}],"mappings":[{"artifact":0,"gen_end":390,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":0,"gen_end":516,"gen_start":390,"node":1,"role":"declaration","source":0,"src_end":276,"src_start":146},{"artifact":0,"gen_end":645,"gen_start":516,"node":2,"role":"declaration","source":0,"src_end":434,"src_start":278},{"artifact":0,"gen_end":3714,"gen_start":645,"node":3,"role":"declaration","source":0,"src_end":659,"src_start":436},{"artifact":0,"gen_end":3886,"gen_start":3714,"node":4,"role":"declaration","source":0,"src_end":899,"src_start":661},{"artifact":0,"gen_end":4151,"gen_start":3886,"node":5,"role":"declaration","source":0,"src_end":1201,"src_start":901},{"artifact":0,"gen_end":4260,"gen_start":4151,"node":6,"role":"declaration","source":0,"src_end":1298,"src_start":1203},{"artifact":0,"gen_end":4412,"gen_start":4260,"node":7,"role":"declaration","source":0,"src_end":1473,"src_start":1300},{"artifact":0,"gen_end":4413,"gen_start":4412,"node":8,"role":"declaration","source":0,"src_end":1565,"src_start":1475},{"artifact":0,"gen_end":7509,"gen_start":4413,"node":9,"role":"declaration","source":0,"src_end":1803,"src_start":1567},{"artifact":0,"gen_end":8854,"gen_start":7509,"node":10,"role":"declaration","source":0,"src_end":2213,"src_start":1805},{"artifact":0,"gen_end":8937,"gen_start":8854,"node":11,"role":"declaration","source":0,"src_end":2305,"src_start":2215},{"artifact":0,"gen_end":9023,"gen_start":8937,"node":12,"role":"declaration","source":0,"src_end":2433,"src_start":2307},{"artifact":0,"gen_end":12068,"gen_start":9023,"node":13,"role":"declaration","source":0,"src_end":2634,"src_start":2435},{"artifact":0,"gen_end":12225,"gen_start":12068,"node":14,"role":"declaration","source":0,"src_end":2817,"src_start":2636},{"artifact":0,"gen_end":20447,"gen_start":12225,"node":15,"role":"declaration","source":0,"src_end":3166,"src_start":2819},{"artifact":0,"gen_end":42522,"gen_start":20447,"node":16,"role":"declaration","source":0,"src_end":3606,"src_start":3168},{"artifact":0,"gen_end":42547,"gen_start":42522,"node":0,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3642,"src_start":0},{"artifact":1,"gen_end":430,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":276,"src_start":146},{"artifact":1,"gen_end":805,"gen_start":430,"node":19,"role":"declaration","source":0,"src_end":434,"src_start":278},{"artifact":1,"gen_end":1090,"gen_start":805,"node":20,"role":"declaration","source":0,"src_end":659,"src_start":436},{"artifact":1,"gen_end":1752,"gen_start":1090,"node":21,"role":"declaration","source":0,"src_end":899,"src_start":661},{"artifact":1,"gen_end":2542,"gen_start":1752,"node":22,"role":"declaration","source":0,"src_end":1201,"src_start":901},{"artifact":1,"gen_end":2959,"gen_start":2542,"node":23,"role":"declaration","source":0,"src_end":1298,"src_start":1203},{"artifact":1,"gen_end":3312,"gen_start":2959,"node":24,"role":"declaration","source":0,"src_end":1473,"src_start":1300},{"artifact":1,"gen_end":3527,"gen_start":3312,"node":25,"role":"declaration","source":0,"src_end":1565,"src_start":1475},{"artifact":1,"gen_end":3850,"gen_start":3527,"node":26,"role":"declaration","source":0,"src_end":1803,"src_start":1567},{"artifact":1,"gen_end":5867,"gen_start":3850,"node":27,"role":"declaration","source":0,"src_end":2213,"src_start":1805},{"artifact":1,"gen_end":6121,"gen_start":5867,"node":28,"role":"declaration","source":0,"src_end":2305,"src_start":2215},{"artifact":1,"gen_end":6454,"gen_start":6121,"node":29,"role":"declaration","source":0,"src_end":2433,"src_start":2307},{"artifact":1,"gen_end":6717,"gen_start":6454,"node":30,"role":"declaration","source":0,"src_end":2634,"src_start":2435},{"artifact":1,"gen_end":7348,"gen_start":6717,"node":31,"role":"declaration","source":0,"src_end":2817,"src_start":2636},{"artifact":1,"gen_end":13192,"gen_start":7348,"node":32,"role":"declaration","source":0,"src_end":3166,"src_start":2819},{"artifact":1,"gen_end":27179,"gen_start":13192,"node":33,"role":"declaration","source":0,"src_end":3606,"src_start":3168},{"artifact":1,"gen_end":27194,"gen_start":27179,"node":17,"role":"declaration","source":0,"src_end":3642,"src_start":0}],"module":"Screening","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"02b315b69b8881ec6f91f78f9b12c6085dc76fa6c7bf1cc658029f081e286c53","source_id":"0057130a9fc0f7ed88a4394b9d3931f003d7ecce5f56d65b920bb48c69bdfc7e","sources":[{"id":0,"kind":"file","path":"src/Screening.lex.tex","sha256":"3dc86d2c1968e2eee6b3f55e1013f2ad4506f81a29a261e767d7dd2029b77efc"}],"spec":"lexlean/source-map/1"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.process.json new file mode 100644 index 000000000..ea4a842f1 --- /dev/null +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.lean diff --git a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.process.json similarity index 95% rename from examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.process.json index acc49a74a..a411745f8 100644 --- a/examples/production-coverage/expected/verify/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af3572b43e36d5c62b7601d32507ebc3a.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.process.json similarity index 90% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.process.json index 966f09413..ec66ea488 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.process.json new file mode 100644 index 000000000..4c51ca005 --- /dev/null +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.process.json similarity index 94% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.process.json index 491d51a6a..8d935b485 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Reasoning","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanReasoning.All' does not depend on any axioms\n'LexLeanReasoning.All.below' does not depend on any axioms\n'LexLeanReasoning.All.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.brecOn' does not depend on any axioms\n'LexLeanReasoning.All.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.recOn' does not depend on any axioms\n'LexLeanReasoning.Complete' does not depend on any axioms\n'LexLeanReasoning.Found' does not depend on any axioms\n'LexLeanReasoning.Found.match_1' does not depend on any axioms\n'LexLeanReasoning.Preserves' does not depend on any axioms\n'LexLeanReasoning.Reaches' does not depend on any axioms\n'LexLeanReasoning.SearchOk' does not depend on any axioms\n'LexLeanReasoning.Sound' does not depend on any axioms\n'LexLeanReasoning.Star' does not depend on any axioms\n'LexLeanReasoning.Star.below' does not depend on any axioms\n'LexLeanReasoning.Star.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.brecOn' does not depend on any axioms\n'LexLeanReasoning.Star.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.recOn' does not depend on any axioms\n'LexLeanReasoning.allAppend' does not depend on any axioms\n'LexLeanReasoning.allFold' does not depend on any axioms\n'LexLeanReasoning.allHead' does not depend on any axioms\n'LexLeanReasoning.allSingle' does not depend on any axioms\n'LexLeanReasoning.allTail' does not depend on any axioms\n'LexLeanReasoning.bltSucc' does not depend on any axioms\n'LexLeanReasoning.capAll' does not depend on any axioms\n'LexLeanReasoning.capBound' does not depend on any axioms\n'LexLeanReasoning.checked' does not depend on any axioms\n'LexLeanReasoning.foldInvariant' does not depend on any axioms\n'LexLeanReasoning.foldSnoc' does not depend on any axioms\n'LexLeanReasoning.freshAll' does not depend on any axioms\n'LexLeanReasoning.guarded' does not depend on any axioms\n'LexLeanReasoning.guardedRank' does not depend on any axioms\n'LexLeanReasoning.iterateUntilBound' does not depend on any axioms\n'LexLeanReasoning.iterateUntilCount' does not depend on any axioms\n'LexLeanReasoning.iterateUntilGrowth' does not depend on any axioms\n'LexLeanReasoning.iterateUntilInvariant' does not depend on any axioms\n'LexLeanReasoning.iterateUntilSimulate' does not depend on any axioms\n'LexLeanReasoning.iterateUntilStops' does not depend on any axioms\n'LexLeanReasoning.lengthSnoc' does not depend on any axioms\n'LexLeanReasoning.noneSome' does not depend on any axioms\n'LexLeanReasoning.peakBound' does not depend on any axioms\n'LexLeanReasoning.reachesStart' does not depend on any axioms\n'LexLeanReasoning.searchStart' does not depend on any axioms\n'LexLeanReasoning.starPreserves' does not depend on any axioms\n'LexLeanReasoning.zeroLe' does not depend on any axioms\n","stdout_sha256":"bcad061b4e8b3848b9d6815070631b4088a7b6b1512ab5c741c66c6dea825fee","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.LexLeanRuntime.Reasoning","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanReasoning.All' does not depend on any axioms\n'LexLeanReasoning.All.below' does not depend on any axioms\n'LexLeanReasoning.All.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.brecOn' does not depend on any axioms\n'LexLeanReasoning.All.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.recOn' does not depend on any axioms\n'LexLeanReasoning.Complete' does not depend on any axioms\n'LexLeanReasoning.Found' does not depend on any axioms\n'LexLeanReasoning.Found.match_1' does not depend on any axioms\n'LexLeanReasoning.Preserves' does not depend on any axioms\n'LexLeanReasoning.Reaches' does not depend on any axioms\n'LexLeanReasoning.SearchOk' does not depend on any axioms\n'LexLeanReasoning.Sound' does not depend on any axioms\n'LexLeanReasoning.Star' does not depend on any axioms\n'LexLeanReasoning.Star.below' does not depend on any axioms\n'LexLeanReasoning.Star.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.brecOn' does not depend on any axioms\n'LexLeanReasoning.Star.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.recOn' does not depend on any axioms\n'LexLeanReasoning.allAppend' does not depend on any axioms\n'LexLeanReasoning.allFold' does not depend on any axioms\n'LexLeanReasoning.allHead' does not depend on any axioms\n'LexLeanReasoning.allSingle' does not depend on any axioms\n'LexLeanReasoning.allTail' does not depend on any axioms\n'LexLeanReasoning.bltSucc' does not depend on any axioms\n'LexLeanReasoning.capAll' does not depend on any axioms\n'LexLeanReasoning.capBound' does not depend on any axioms\n'LexLeanReasoning.checked' does not depend on any axioms\n'LexLeanReasoning.foldInvariant' does not depend on any axioms\n'LexLeanReasoning.foldSnoc' does not depend on any axioms\n'LexLeanReasoning.freshAll' does not depend on any axioms\n'LexLeanReasoning.guarded' does not depend on any axioms\n'LexLeanReasoning.guardedRank' does not depend on any axioms\n'LexLeanReasoning.iterateUntilBound' does not depend on any axioms\n'LexLeanReasoning.iterateUntilCount' does not depend on any axioms\n'LexLeanReasoning.iterateUntilGrowth' does not depend on any axioms\n'LexLeanReasoning.iterateUntilInvariant' does not depend on any axioms\n'LexLeanReasoning.iterateUntilSimulate' does not depend on any axioms\n'LexLeanReasoning.iterateUntilStops' does not depend on any axioms\n'LexLeanReasoning.lengthSnoc' does not depend on any axioms\n'LexLeanReasoning.noneSome' does not depend on any axioms\n'LexLeanReasoning.peakBound' does not depend on any axioms\n'LexLeanReasoning.reachesStart' does not depend on any axioms\n'LexLeanReasoning.searchStart' does not depend on any axioms\n'LexLeanReasoning.starPreserves' does not depend on any axioms\n'LexLeanReasoning.zeroLe' does not depend on any axioms\n","stdout_sha256":"bcad061b4e8b3848b9d6815070631b4088a7b6b1512ab5c741c66c6dea825fee","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.process.json similarity index 96% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.process.json index eb7d96e1d..37f866fd9 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Budget","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Budget.Burn.apply' does not depend on any axioms\n'Reasoning.Budget.Burn.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Burn.apply_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Burn.candidates' does not depend on any axioms\n'Reasoning.Budget.Burn.conclusion' does not depend on any axioms\n'Reasoning.Budget.Burn.guard' does not depend on any axioms\n'Reasoning.Budget.Drained.sound' depends on axioms: [propext]\n'Reasoning.Budget.Empty' does not depend on any axioms\n'Reasoning.Budget.Refund' does not depend on any axioms\n'Reasoning.Budget.Refund.Ledger' does not depend on any axioms\n'Reasoning.Budget.Refund.Run' does not depend on any axioms\n'Reasoning.Budget.Refund.Step' does not depend on any axioms\n'Reasoning.Budget.Refund.accept' does not depend on any axioms\n'Reasoning.Budget.Refund.accept_sound' depends on axioms: [propext]\n'Reasoning.Budget.Refund.account' does not depend on any axioms\n'Reasoning.Budget.Refund.answer' does not depend on any axioms\n'Reasoning.Budget.Refund.attempts' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude_accept' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude_sound' depends on axioms: [propext]\n'Reasoning.Budget.Refund.derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.explained' depends on axioms: [propext]\n'Reasoning.Budget.Refund.extract' does not depend on any axioms\n'Reasoning.Budget.Refund.fire' does not depend on any axioms\n'Reasoning.Budget.Refund.fire_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.firings_bounded' does not depend on any axioms\n'Reasoning.Budget.Refund.follow' does not depend on any axioms\n'Reasoning.Budget.Refund.iterations_bounded' does not depend on any axioms\n'Reasoning.Budget.Refund.next' does not depend on any axioms\n'Reasoning.Budget.Refund.next_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.observe' does not depend on any axioms\n'Reasoning.Budget.Refund.replay' does not depend on any axioms\n'Reasoning.Budget.Refund.replay_fire' does not depend on any axioms\n'Reasoning.Budget.Refund.replay_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.run' does not depend on any axioms\n'Reasoning.Budget.Refund.run_state' does not depend on any axioms\n'Reasoning.Budget.Refund.run_trace' does not depend on any axioms\n'Reasoning.Budget.Refund.saturate' does not depend on any axioms\n'Reasoning.Budget.Refund.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.select' does not depend on any axioms\n'Reasoning.Budget.Refund.start' does not depend on any axioms\n'Reasoning.Budget.Refund.step' does not depend on any axioms\n'Reasoning.Budget.Refund.step_count' does not depend on any axioms\n'Reasoning.Budget.Refund.step_fired' does not depend on any axioms\n'Reasoning.Budget.Refund.step_none' does not depend on any axioms\n'Reasoning.Budget.Refund.step_some' does not depend on any axioms\n'Reasoning.Budget.Refund.step_trace' does not depend on any axioms\n'Reasoning.Budget.Refund.verdict' does not depend on any axioms\n'Reasoning.Budget.Refund.verdict_sound' depends on axioms: [propext]\n'Reasoning.Budget.Remaining' does not depend on any axioms\n'Reasoning.Budget.Spend' does not depend on any axioms\n'Reasoning.Budget.Spend.Ledger' does not depend on any axioms\n'Reasoning.Budget.Spend.Run' does not depend on any axioms\n'Reasoning.Budget.Spend.Step' does not depend on any axioms\n'Reasoning.Budget.Spend.accept' does not depend on any axioms\n'Reasoning.Budget.Spend.accept_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spend.account' does not depend on any axioms\n'Reasoning.Budget.Spend.answer' does not depend on any axioms\n'Reasoning.Budget.Spend.attempts' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude_accept' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spend.derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.explained' depends on axioms: [propext]\n'Reasoning.Budget.Spend.extract' does not depend on any axioms\n'Reasoning.Budget.Spend.fire' does not depend on any axioms\n'Reasoning.Budget.Spend.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.fire_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.firings_bounded' does not depend on any axioms\n'Reasoning.Budget.Spend.follow' does not depend on any axioms\n'Reasoning.Budget.Spend.iterations_bounded' does not depend on any axioms\n'Reasoning.Budget.Spend.next' does not depend on any axioms\n'Reasoning.Budget.Spend.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.next_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.observe' does not depend on any axioms\n'Reasoning.Budget.Spend.replay' does not depend on any axioms\n'Reasoning.Budget.Spend.replay_fire' does not depend on any axioms\n'Reasoning.Budget.Spend.replay_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.run' does not depend on any axioms\n'Reasoning.Budget.Spend.run_state' does not depend on any axioms\n'Reasoning.Budget.Spend.run_trace' does not depend on any axioms\n'Reasoning.Budget.Spend.saturate' does not depend on any axioms\n'Reasoning.Budget.Spend.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.saturates' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.select' does not depend on any axioms\n'Reasoning.Budget.Spend.start' does not depend on any axioms\n'Reasoning.Budget.Spend.step' does not depend on any axioms\n'Reasoning.Budget.Spend.step_count' does not depend on any axioms\n'Reasoning.Budget.Spend.step_fired' does not depend on any axioms\n'Reasoning.Budget.Spend.step_none' does not depend on any axioms\n'Reasoning.Budget.Spend.step_some' does not depend on any axioms\n'Reasoning.Budget.Spend.step_trace' does not depend on any axioms\n'Reasoning.Budget.Spend.verdict' does not depend on any axioms\n'Reasoning.Budget.Spend.verdict_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spent' does not depend on any axioms\n'Reasoning.Budget.Tick.apply' does not depend on any axioms\n'Reasoning.Budget.Tick.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Tick.apply_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Tick.conclusion' does not depend on any axioms\n'Reasoning.Budget.Tick.guard' does not depend on any axioms\n'Reasoning.Budget.allowance_bound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.burn_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.burn_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.emptyCheck' does not depend on any axioms\n'Reasoning.Budget.empty_sound' depends on axioms: [propext]\n'Reasoning.Budget.tick_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.tick_sound' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"61274b9278738a5387ec49d25adf40a85f958c84f3e7007db22fe5da1fa0f781","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Budget","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Budget.Burn.apply' does not depend on any axioms\n'Reasoning.Budget.Burn.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Burn.apply_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Burn.candidates' does not depend on any axioms\n'Reasoning.Budget.Burn.conclusion' does not depend on any axioms\n'Reasoning.Budget.Burn.guard' does not depend on any axioms\n'Reasoning.Budget.Drained.sound' depends on axioms: [propext]\n'Reasoning.Budget.Empty' does not depend on any axioms\n'Reasoning.Budget.Refund' does not depend on any axioms\n'Reasoning.Budget.Refund.Ledger' does not depend on any axioms\n'Reasoning.Budget.Refund.Run' does not depend on any axioms\n'Reasoning.Budget.Refund.Step' does not depend on any axioms\n'Reasoning.Budget.Refund.accept' does not depend on any axioms\n'Reasoning.Budget.Refund.accept_sound' depends on axioms: [propext]\n'Reasoning.Budget.Refund.account' does not depend on any axioms\n'Reasoning.Budget.Refund.answer' does not depend on any axioms\n'Reasoning.Budget.Refund.attempts' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude_accept' does not depend on any axioms\n'Reasoning.Budget.Refund.conclude_sound' depends on axioms: [propext]\n'Reasoning.Budget.Refund.derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.explained' depends on axioms: [propext]\n'Reasoning.Budget.Refund.extract' does not depend on any axioms\n'Reasoning.Budget.Refund.fire' does not depend on any axioms\n'Reasoning.Budget.Refund.fire_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.firings_bounded' does not depend on any axioms\n'Reasoning.Budget.Refund.follow' does not depend on any axioms\n'Reasoning.Budget.Refund.iterations_bounded' does not depend on any axioms\n'Reasoning.Budget.Refund.next' does not depend on any axioms\n'Reasoning.Budget.Refund.next_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.observe' does not depend on any axioms\n'Reasoning.Budget.Refund.replay' does not depend on any axioms\n'Reasoning.Budget.Refund.replay_fire' does not depend on any axioms\n'Reasoning.Budget.Refund.replay_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.run' does not depend on any axioms\n'Reasoning.Budget.Refund.run_state' does not depend on any axioms\n'Reasoning.Budget.Refund.run_trace' does not depend on any axioms\n'Reasoning.Budget.Refund.saturate' does not depend on any axioms\n'Reasoning.Budget.Refund.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Refund.select' does not depend on any axioms\n'Reasoning.Budget.Refund.start' does not depend on any axioms\n'Reasoning.Budget.Refund.step' does not depend on any axioms\n'Reasoning.Budget.Refund.step_count' does not depend on any axioms\n'Reasoning.Budget.Refund.step_fired' does not depend on any axioms\n'Reasoning.Budget.Refund.step_none' does not depend on any axioms\n'Reasoning.Budget.Refund.step_some' does not depend on any axioms\n'Reasoning.Budget.Refund.step_trace' does not depend on any axioms\n'Reasoning.Budget.Refund.verdict' does not depend on any axioms\n'Reasoning.Budget.Refund.verdict_sound' depends on axioms: [propext]\n'Reasoning.Budget.Remaining' does not depend on any axioms\n'Reasoning.Budget.Spend' does not depend on any axioms\n'Reasoning.Budget.Spend.Ledger' does not depend on any axioms\n'Reasoning.Budget.Spend.Run' does not depend on any axioms\n'Reasoning.Budget.Spend.Step' does not depend on any axioms\n'Reasoning.Budget.Spend.accept' does not depend on any axioms\n'Reasoning.Budget.Spend.accept_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spend.account' does not depend on any axioms\n'Reasoning.Budget.Spend.answer' does not depend on any axioms\n'Reasoning.Budget.Spend.attempts' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude_accept' does not depend on any axioms\n'Reasoning.Budget.Spend.conclude_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spend.derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.explained' depends on axioms: [propext]\n'Reasoning.Budget.Spend.extract' does not depend on any axioms\n'Reasoning.Budget.Spend.fire' does not depend on any axioms\n'Reasoning.Budget.Spend.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.fire_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.firings_bounded' does not depend on any axioms\n'Reasoning.Budget.Spend.follow' does not depend on any axioms\n'Reasoning.Budget.Spend.iterations_bounded' does not depend on any axioms\n'Reasoning.Budget.Spend.next' does not depend on any axioms\n'Reasoning.Budget.Spend.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.next_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.observe' does not depend on any axioms\n'Reasoning.Budget.Spend.replay' does not depend on any axioms\n'Reasoning.Budget.Spend.replay_fire' does not depend on any axioms\n'Reasoning.Budget.Spend.replay_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.run' does not depend on any axioms\n'Reasoning.Budget.Spend.run_state' does not depend on any axioms\n'Reasoning.Budget.Spend.run_trace' does not depend on any axioms\n'Reasoning.Budget.Spend.saturate' does not depend on any axioms\n'Reasoning.Budget.Spend.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.saturates' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Spend.select' does not depend on any axioms\n'Reasoning.Budget.Spend.start' does not depend on any axioms\n'Reasoning.Budget.Spend.step' does not depend on any axioms\n'Reasoning.Budget.Spend.step_count' does not depend on any axioms\n'Reasoning.Budget.Spend.step_fired' does not depend on any axioms\n'Reasoning.Budget.Spend.step_none' does not depend on any axioms\n'Reasoning.Budget.Spend.step_some' does not depend on any axioms\n'Reasoning.Budget.Spend.step_trace' does not depend on any axioms\n'Reasoning.Budget.Spend.verdict' does not depend on any axioms\n'Reasoning.Budget.Spend.verdict_sound' depends on axioms: [propext]\n'Reasoning.Budget.Spent' does not depend on any axioms\n'Reasoning.Budget.Tick.apply' does not depend on any axioms\n'Reasoning.Budget.Tick.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Tick.apply_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.Tick.conclusion' does not depend on any axioms\n'Reasoning.Budget.Tick.guard' does not depend on any axioms\n'Reasoning.Budget.allowance_bound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.burn_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.burn_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.emptyCheck' does not depend on any axioms\n'Reasoning.Budget.empty_sound' depends on axioms: [propext]\n'Reasoning.Budget.tick_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Budget.tick_sound' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"61274b9278738a5387ec49d25adf40a85f958c84f3e7007db22fe5da1fa0f781","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.process.json similarity index 98% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.process.json index ab1cf5347..bd799d333 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Clinic","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Clinic.Chart' does not depend on any axioms\n'Reasoning.Clinic.Consistent' does not depend on any axioms\n'Reasoning.Clinic.Discharged' does not depend on any axioms\n'Reasoning.Clinic.Escalate.apply' does not depend on any axioms\n'Reasoning.Clinic.Escalate.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Escalate.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Escalate.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Escalate.guard' does not depend on any axioms\n'Reasoning.Clinic.Febrile' does not depend on any axioms\n'Reasoning.Clinic.Fever.apply' does not depend on any axioms\n'Reasoning.Clinic.Fever.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Fever.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Fever.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Fever.guard' does not depend on any axioms\n'Reasoning.Clinic.Findings.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Hypotensive' does not depend on any axioms\n'Reasoning.Clinic.Indicated' does not depend on any axioms\n'Reasoning.Clinic.Justified' does not depend on any axioms\n'Reasoning.Clinic.Leukocytic' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.apply' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Leukocytosis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Leukocytosis.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.guard' does not depend on any axioms\n'Reasoning.Clinic.Outpatient.sound' depends on axioms: [propext]\n'Reasoning.Clinic.Pending' does not depend on any axioms\n'Reasoning.Clinic.Recommendation.complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Recommendation.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review' does not depend on any axioms\n'Reasoning.Clinic.Review.Ledger' does not depend on any axioms\n'Reasoning.Clinic.Review.Run' does not depend on any axioms\n'Reasoning.Clinic.Review.Step' does not depend on any axioms\n'Reasoning.Clinic.Review.accept' does not depend on any axioms\n'Reasoning.Clinic.Review.accept_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Review.account' does not depend on any axioms\n'Reasoning.Clinic.Review.answer' does not depend on any axioms\n'Reasoning.Clinic.Review.attempts' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude_accept' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Review.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.explained' depends on axioms: [propext]\n'Reasoning.Clinic.Review.extract' does not depend on any axioms\n'Reasoning.Clinic.Review.fire' does not depend on any axioms\n'Reasoning.Clinic.Review.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.firings_bounded' does not depend on any axioms\n'Reasoning.Clinic.Review.follow' does not depend on any axioms\n'Reasoning.Clinic.Review.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.iterations_bounded' does not depend on any axioms\n'Reasoning.Clinic.Review.next' does not depend on any axioms\n'Reasoning.Clinic.Review.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.observe' does not depend on any axioms\n'Reasoning.Clinic.Review.replay' does not depend on any axioms\n'Reasoning.Clinic.Review.replay_fire' does not depend on any axioms\n'Reasoning.Clinic.Review.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.run' does not depend on any axioms\n'Reasoning.Clinic.Review.run_state' does not depend on any axioms\n'Reasoning.Clinic.Review.run_trace' does not depend on any axioms\n'Reasoning.Clinic.Review.saturate' does not depend on any axioms\n'Reasoning.Clinic.Review.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.select' does not depend on any axioms\n'Reasoning.Clinic.Review.start' does not depend on any axioms\n'Reasoning.Clinic.Review.step' does not depend on any axioms\n'Reasoning.Clinic.Review.step_count' does not depend on any axioms\n'Reasoning.Clinic.Review.step_fired' does not depend on any axioms\n'Reasoning.Clinic.Review.step_none' does not depend on any axioms\n'Reasoning.Clinic.Review.step_some' does not depend on any axioms\n'Reasoning.Clinic.Review.step_trace' does not depend on any axioms\n'Reasoning.Clinic.Review.verdict' does not depend on any axioms\n'Reasoning.Clinic.Review.verdict_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Sepsis.apply' does not depend on any axioms\n'Reasoning.Clinic.Sepsis.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Sepsis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Sepsis.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Sepsis.guard' does not depend on any axioms\n'Reasoning.Clinic.Shock.apply' does not depend on any axioms\n'Reasoning.Clinic.Shock.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Shock.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Shock.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Shock.guard' does not depend on any axioms\n'Reasoning.Clinic.Sirs.apply' does not depend on any axioms\n'Reasoning.Clinic.Sirs.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Sirs.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Sirs.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Sirs.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.apply' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Tachycardia.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Tachycardia.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachycardic' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.apply' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Tachypnea.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Tachypnea.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachypneic' does not depend on any axioms\n'Reasoning.Clinic.Triage' does not depend on any axioms\n'Reasoning.Clinic.Triage.Ledger' does not depend on any axioms\n'Reasoning.Clinic.Triage.Run' does not depend on any axioms\n'Reasoning.Clinic.Triage.Step' does not depend on any axioms\n'Reasoning.Clinic.Triage.accept' does not depend on any axioms\n'Reasoning.Clinic.Triage.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.account' does not depend on any axioms\n'Reasoning.Clinic.Triage.answer' does not depend on any axioms\n'Reasoning.Clinic.Triage.attempts' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude_accept' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.extract' does not depend on any axioms\n'Reasoning.Clinic.Triage.fire' does not depend on any axioms\n'Reasoning.Clinic.Triage.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Triage.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.firings_bounded' does not depend on any axioms\n'Reasoning.Clinic.Triage.follow' does not depend on any axioms\n'Reasoning.Clinic.Triage.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.iterations_bounded' does not depend on any axioms\n'Reasoning.Clinic.Triage.next' does not depend on any axioms\n'Reasoning.Clinic.Triage.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Triage.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.observe' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay_fire' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.run' does not depend on any axioms\n'Reasoning.Clinic.Triage.run_state' does not depend on any axioms\n'Reasoning.Clinic.Triage.run_trace' does not depend on any axioms\n'Reasoning.Clinic.Triage.saturate' does not depend on any axioms\n'Reasoning.Clinic.Triage.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.select' does not depend on any axioms\n'Reasoning.Clinic.Triage.start' does not depend on any axioms\n'Reasoning.Clinic.Triage.step' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_count' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_fired' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_none' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_some' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_trace' does not depend on any axioms\n'Reasoning.Clinic.Triage.verdict' does not depend on any axioms\n'Reasoning.Clinic.Triage.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Vitals' does not depend on any axioms\n'Reasoning.Clinic.Warranted' does not depend on any axioms\n'Reasoning.Clinic.admitted_consistent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.admitted_pending' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.consistent_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.dischargeCheck' does not depend on any axioms\n'Reasoning.Clinic.discharge_sound' depends on axioms: [propext]\n'Reasoning.Clinic.escalate_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.escalate_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.fever_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.fever_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.feverish' does not depend on any axioms\n'Reasoning.Clinic.hypotensive' does not depend on any axioms\n'Reasoning.Clinic.leukocytic' does not depend on any axioms\n'Reasoning.Clinic.leukocytosis_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.leukocytosis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.recommendationCheck' does not depend on any axioms\n'Reasoning.Clinic.recommendation_complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.recommendation_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.sepsis_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.sepsis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.shock_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.shock_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.sirs_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.sirs_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachycardia_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.tachycardia_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachycardic' does not depend on any axioms\n'Reasoning.Clinic.tachypnea_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.tachypnea_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachypneic' does not depend on any axioms\n","stdout_sha256":"d385d180f0ca2a66d16d21a13c5c0cb09098259b2c56ec20e64bef35d7d23d18","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Clinic","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Clinic.Chart' does not depend on any axioms\n'Reasoning.Clinic.Consistent' does not depend on any axioms\n'Reasoning.Clinic.Discharged' does not depend on any axioms\n'Reasoning.Clinic.Escalate.apply' does not depend on any axioms\n'Reasoning.Clinic.Escalate.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Escalate.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Escalate.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Escalate.guard' does not depend on any axioms\n'Reasoning.Clinic.Febrile' does not depend on any axioms\n'Reasoning.Clinic.Fever.apply' does not depend on any axioms\n'Reasoning.Clinic.Fever.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Fever.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Fever.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Fever.guard' does not depend on any axioms\n'Reasoning.Clinic.Findings.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Hypotensive' does not depend on any axioms\n'Reasoning.Clinic.Indicated' does not depend on any axioms\n'Reasoning.Clinic.Justified' does not depend on any axioms\n'Reasoning.Clinic.Leukocytic' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.apply' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Leukocytosis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Leukocytosis.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Leukocytosis.guard' does not depend on any axioms\n'Reasoning.Clinic.Outpatient.sound' depends on axioms: [propext]\n'Reasoning.Clinic.Pending' does not depend on any axioms\n'Reasoning.Clinic.Recommendation.complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Recommendation.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review' does not depend on any axioms\n'Reasoning.Clinic.Review.Ledger' does not depend on any axioms\n'Reasoning.Clinic.Review.Run' does not depend on any axioms\n'Reasoning.Clinic.Review.Step' does not depend on any axioms\n'Reasoning.Clinic.Review.accept' does not depend on any axioms\n'Reasoning.Clinic.Review.accept_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Review.account' does not depend on any axioms\n'Reasoning.Clinic.Review.answer' does not depend on any axioms\n'Reasoning.Clinic.Review.attempts' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude_accept' does not depend on any axioms\n'Reasoning.Clinic.Review.conclude_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Review.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.explained' depends on axioms: [propext]\n'Reasoning.Clinic.Review.extract' does not depend on any axioms\n'Reasoning.Clinic.Review.fire' does not depend on any axioms\n'Reasoning.Clinic.Review.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.firings_bounded' does not depend on any axioms\n'Reasoning.Clinic.Review.follow' does not depend on any axioms\n'Reasoning.Clinic.Review.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.iterations_bounded' does not depend on any axioms\n'Reasoning.Clinic.Review.next' does not depend on any axioms\n'Reasoning.Clinic.Review.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.observe' does not depend on any axioms\n'Reasoning.Clinic.Review.replay' does not depend on any axioms\n'Reasoning.Clinic.Review.replay_fire' does not depend on any axioms\n'Reasoning.Clinic.Review.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.run' does not depend on any axioms\n'Reasoning.Clinic.Review.run_state' does not depend on any axioms\n'Reasoning.Clinic.Review.run_trace' does not depend on any axioms\n'Reasoning.Clinic.Review.saturate' does not depend on any axioms\n'Reasoning.Clinic.Review.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Review.select' does not depend on any axioms\n'Reasoning.Clinic.Review.start' does not depend on any axioms\n'Reasoning.Clinic.Review.step' does not depend on any axioms\n'Reasoning.Clinic.Review.step_count' does not depend on any axioms\n'Reasoning.Clinic.Review.step_fired' does not depend on any axioms\n'Reasoning.Clinic.Review.step_none' does not depend on any axioms\n'Reasoning.Clinic.Review.step_some' does not depend on any axioms\n'Reasoning.Clinic.Review.step_trace' does not depend on any axioms\n'Reasoning.Clinic.Review.verdict' does not depend on any axioms\n'Reasoning.Clinic.Review.verdict_sound' depends on axioms: [propext]\n'Reasoning.Clinic.Sepsis.apply' does not depend on any axioms\n'Reasoning.Clinic.Sepsis.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Sepsis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Sepsis.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Sepsis.guard' does not depend on any axioms\n'Reasoning.Clinic.Shock.apply' does not depend on any axioms\n'Reasoning.Clinic.Shock.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Shock.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Shock.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Shock.guard' does not depend on any axioms\n'Reasoning.Clinic.Sirs.apply' does not depend on any axioms\n'Reasoning.Clinic.Sirs.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Sirs.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Sirs.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Sirs.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.apply' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Tachycardia.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Tachycardia.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Tachycardia.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachycardic' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.apply' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.apply_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Tachypnea.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Tachypnea.conclusion' does not depend on any axioms\n'Reasoning.Clinic.Tachypnea.guard' does not depend on any axioms\n'Reasoning.Clinic.Tachypneic' does not depend on any axioms\n'Reasoning.Clinic.Triage' does not depend on any axioms\n'Reasoning.Clinic.Triage.Ledger' does not depend on any axioms\n'Reasoning.Clinic.Triage.Run' does not depend on any axioms\n'Reasoning.Clinic.Triage.Step' does not depend on any axioms\n'Reasoning.Clinic.Triage.accept' does not depend on any axioms\n'Reasoning.Clinic.Triage.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.account' does not depend on any axioms\n'Reasoning.Clinic.Triage.answer' does not depend on any axioms\n'Reasoning.Clinic.Triage.attempts' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude_accept' does not depend on any axioms\n'Reasoning.Clinic.Triage.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.extract' does not depend on any axioms\n'Reasoning.Clinic.Triage.fire' does not depend on any axioms\n'Reasoning.Clinic.Triage.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Triage.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.firings_bounded' does not depend on any axioms\n'Reasoning.Clinic.Triage.follow' does not depend on any axioms\n'Reasoning.Clinic.Triage.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.iterations_bounded' does not depend on any axioms\n'Reasoning.Clinic.Triage.next' does not depend on any axioms\n'Reasoning.Clinic.Triage.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.Triage.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.observe' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay_fire' does not depend on any axioms\n'Reasoning.Clinic.Triage.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.run' does not depend on any axioms\n'Reasoning.Clinic.Triage.run_state' does not depend on any axioms\n'Reasoning.Clinic.Triage.run_trace' does not depend on any axioms\n'Reasoning.Clinic.Triage.saturate' does not depend on any axioms\n'Reasoning.Clinic.Triage.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Triage.select' does not depend on any axioms\n'Reasoning.Clinic.Triage.start' does not depend on any axioms\n'Reasoning.Clinic.Triage.step' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_count' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_fired' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_none' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_some' does not depend on any axioms\n'Reasoning.Clinic.Triage.step_trace' does not depend on any axioms\n'Reasoning.Clinic.Triage.verdict' does not depend on any axioms\n'Reasoning.Clinic.Triage.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.Vitals' does not depend on any axioms\n'Reasoning.Clinic.Warranted' does not depend on any axioms\n'Reasoning.Clinic.admitted_consistent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.admitted_pending' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.consistent_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.dischargeCheck' does not depend on any axioms\n'Reasoning.Clinic.discharge_sound' depends on axioms: [propext]\n'Reasoning.Clinic.escalate_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.escalate_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.fever_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.fever_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.feverish' does not depend on any axioms\n'Reasoning.Clinic.hypotensive' does not depend on any axioms\n'Reasoning.Clinic.leukocytic' does not depend on any axioms\n'Reasoning.Clinic.leukocytosis_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.leukocytosis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.recommendationCheck' does not depend on any axioms\n'Reasoning.Clinic.recommendation_complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.recommendation_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.sepsis_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.sepsis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.shock_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.shock_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.sirs_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.sirs_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachycardia_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.tachycardia_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachycardic' does not depend on any axioms\n'Reasoning.Clinic.tachypnea_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Clinic.tachypnea_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Clinic.tachypneic' does not depend on any axioms\n","stdout_sha256":"d385d180f0ca2a66d16d21a13c5c0cb09098259b2c56ec20e64bef35d7d23d18","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.process.json similarity index 97% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.process.json index 3e6e8fbcc..7cb2cf035 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Main.Cap' does not depend on any axioms\n'Reasoning.Main.Cap.Ledger' does not depend on any axioms\n'Reasoning.Main.Cap.Run' does not depend on any axioms\n'Reasoning.Main.Cap.Step' does not depend on any axioms\n'Reasoning.Main.Cap.accept' does not depend on any axioms\n'Reasoning.Main.Cap.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.account' does not depend on any axioms\n'Reasoning.Main.Cap.answer' does not depend on any axioms\n'Reasoning.Main.Cap.attempts' does not depend on any axioms\n'Reasoning.Main.Cap.conclude' does not depend on any axioms\n'Reasoning.Main.Cap.conclude_accept' does not depend on any axioms\n'Reasoning.Main.Cap.conclude_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.explained' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.extract' does not depend on any axioms\n'Reasoning.Main.Cap.fire' does not depend on any axioms\n'Reasoning.Main.Cap.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.firings_bounded' does not depend on any axioms\n'Reasoning.Main.Cap.follow' does not depend on any axioms\n'Reasoning.Main.Cap.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.iterations_bounded' does not depend on any axioms\n'Reasoning.Main.Cap.next' does not depend on any axioms\n'Reasoning.Main.Cap.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.observe' does not depend on any axioms\n'Reasoning.Main.Cap.replay' does not depend on any axioms\n'Reasoning.Main.Cap.replay_fire' does not depend on any axioms\n'Reasoning.Main.Cap.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.run' does not depend on any axioms\n'Reasoning.Main.Cap.run_state' does not depend on any axioms\n'Reasoning.Main.Cap.run_trace' does not depend on any axioms\n'Reasoning.Main.Cap.saturate' does not depend on any axioms\n'Reasoning.Main.Cap.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.select' does not depend on any axioms\n'Reasoning.Main.Cap.start' does not depend on any axioms\n'Reasoning.Main.Cap.step' does not depend on any axioms\n'Reasoning.Main.Cap.step_count' does not depend on any axioms\n'Reasoning.Main.Cap.step_fired' does not depend on any axioms\n'Reasoning.Main.Cap.step_none' does not depend on any axioms\n'Reasoning.Main.Cap.step_some' does not depend on any axioms\n'Reasoning.Main.Cap.step_trace' does not depend on any axioms\n'Reasoning.Main.Cap.verdict' does not depend on any axioms\n'Reasoning.Main.Cap.verdict_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Capped' does not depend on any axioms\n'Reasoning.Main.Ceiling.sound' depends on axioms: [propext]\n'Reasoning.Main.GatewayEvidence.gateway_safe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.GatewayModel' does not depend on any axioms\n'Reasoning.Main.GatewayTriage' does not depend on any axioms\n'Reasoning.Main.Grade' does not depend on any axioms\n'Reasoning.Main.Grade.Ledger' does not depend on any axioms\n'Reasoning.Main.Grade.Run' does not depend on any axioms\n'Reasoning.Main.Grade.Step' does not depend on any axioms\n'Reasoning.Main.Grade.accept' does not depend on any axioms\n'Reasoning.Main.Grade.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.account' does not depend on any axioms\n'Reasoning.Main.Grade.answer' does not depend on any axioms\n'Reasoning.Main.Grade.attempts' does not depend on any axioms\n'Reasoning.Main.Grade.conclude' does not depend on any axioms\n'Reasoning.Main.Grade.conclude_accept' does not depend on any axioms\n'Reasoning.Main.Grade.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.extract' does not depend on any axioms\n'Reasoning.Main.Grade.fire' does not depend on any axioms\n'Reasoning.Main.Grade.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Grade.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.firings_bounded' does not depend on any axioms\n'Reasoning.Main.Grade.follow' does not depend on any axioms\n'Reasoning.Main.Grade.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.iterations_bounded' does not depend on any axioms\n'Reasoning.Main.Grade.next' does not depend on any axioms\n'Reasoning.Main.Grade.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.next_preserves_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Grade.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.observe' does not depend on any axioms\n'Reasoning.Main.Grade.replay' does not depend on any axioms\n'Reasoning.Main.Grade.replay_fire' does not depend on any axioms\n'Reasoning.Main.Grade.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.run' does not depend on any axioms\n'Reasoning.Main.Grade.run_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.run_state' does not depend on any axioms\n'Reasoning.Main.Grade.run_trace' does not depend on any axioms\n'Reasoning.Main.Grade.saturate' does not depend on any axioms\n'Reasoning.Main.Grade.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturate_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.select' does not depend on any axioms\n'Reasoning.Main.Grade.start' does not depend on any axioms\n'Reasoning.Main.Grade.step' does not depend on any axioms\n'Reasoning.Main.Grade.step_count' does not depend on any axioms\n'Reasoning.Main.Grade.step_fired' does not depend on any axioms\n'Reasoning.Main.Grade.step_none' does not depend on any axioms\n'Reasoning.Main.Grade.step_some' does not depend on any axioms\n'Reasoning.Main.Grade.step_trace' does not depend on any axioms\n'Reasoning.Main.Grade.verdict' does not depend on any axioms\n'Reasoning.Main.Grade.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Graded' does not depend on any axioms\n'Reasoning.Main.Guaranteed' does not depend on any axioms\n'Reasoning.Main.Related' does not depend on any axioms\n'Reasoning.Main.Scale.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.cap_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.cappedCheck' does not depend on any axioms\n'Reasoning.Main.capped_sound' depends on axioms: [propext]\n'Reasoning.Main.doseLevel' does not depend on any axioms\n'Reasoning.Main.dose_exhausted' does not depend on any axioms\n'Reasoning.Main.dose_exhausted_ledger' does not depend on any axioms\n'Reasoning.Main.dose_found' does not depend on any axioms\n'Reasoning.Main.dose_ledger' does not depend on any axioms\n'Reasoning.Main.gatewayLevel' does not depend on any axioms\n'Reasoning.Main.gateway_level' does not depend on any axioms\n'Reasoning.Main.gateway_safe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.gradeLevel' does not depend on any axioms\n'Reasoning.Main.grade_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.grade_correct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.grade_ledger' does not depend on any axioms\n'Reasoning.Main.grade_pending' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.grade_shock' does not depend on any axioms\n'Reasoning.Main.grade_well_ledger' does not depend on any axioms\n'Reasoning.Main.gradedCheck' does not depend on any axioms\n'Reasoning.Main.graded_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.planLeft' depends on axioms: [propext]\n'Reasoning.Main.plan_found' depends on axioms: [propext]\n'Reasoning.Main.plan_frontier' depends on axioms: [propext]\n'Reasoning.Main.plan_ledger' depends on axioms: [propext]\n'Reasoning.Main.plan_unsolved' depends on axioms: [propext]\n'Reasoning.Main.plan_unsolved_ledger' depends on axioms: [propext]\n'Reasoning.Main.refund_drained' does not depend on any axioms\n'Reasoning.Main.refund_ledger' does not depend on any axioms\n'Reasoning.Main.refund_unsolved' does not depend on any axioms\n'Reasoning.Main.refund_unsolved_ledger' does not depend on any axioms\n'Reasoning.Main.related_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.related_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.review_exhausted' does not depend on any axioms\n'Reasoning.Main.review_ledger' does not depend on any axioms\n'Reasoning.Main.review_rejected' does not depend on any axioms\n'Reasoning.Main.review_rejected_ledger' does not depend on any axioms\n'Reasoning.Main.screenDose' does not depend on any axioms\n'Reasoning.Main.screen_found' does not depend on any axioms\n'Reasoning.Main.screen_ledger' does not depend on any axioms\n'Reasoning.Main.screen_truncated' does not depend on any axioms\n'Reasoning.Main.screen_truncated_ledger' does not depend on any axioms\n'Reasoning.Main.screen_unsolved_ledger' does not depend on any axioms\n'Reasoning.Main.spendLeft' does not depend on any axioms\n'Reasoning.Main.spend_drained' does not depend on any axioms\n'Reasoning.Main.spend_ledger' does not depend on any axioms\n'Reasoning.Main.triageLevel' does not depend on any axioms\n'Reasoning.Main.triageSteps' does not depend on any axioms\n'Reasoning.Main.triage_forged' does not depend on any axioms\n'Reasoning.Main.triage_inapplicable' does not depend on any axioms\n'Reasoning.Main.triage_iterations' does not depend on any axioms\n'Reasoning.Main.triage_ledger' does not depend on any axioms\n'Reasoning.Main.triage_level' does not depend on any axioms\n'Reasoning.Main.triage_replays' does not depend on any axioms\n'Reasoning.Main.triage_shock' does not depend on any axioms\n'Reasoning.Main.triage_well' does not depend on any axioms\n'Reasoning.Main.triage_well_ledger' does not depend on any axioms\n","stdout_sha256":"13bfab88bf1e8f71fc26deed8cf04a2a08de1934d83603a6cc29cf959867360f","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Main.Cap' does not depend on any axioms\n'Reasoning.Main.Cap.Ledger' does not depend on any axioms\n'Reasoning.Main.Cap.Run' does not depend on any axioms\n'Reasoning.Main.Cap.Step' does not depend on any axioms\n'Reasoning.Main.Cap.accept' does not depend on any axioms\n'Reasoning.Main.Cap.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.account' does not depend on any axioms\n'Reasoning.Main.Cap.answer' does not depend on any axioms\n'Reasoning.Main.Cap.attempts' does not depend on any axioms\n'Reasoning.Main.Cap.conclude' does not depend on any axioms\n'Reasoning.Main.Cap.conclude_accept' does not depend on any axioms\n'Reasoning.Main.Cap.conclude_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.explained' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Cap.extract' does not depend on any axioms\n'Reasoning.Main.Cap.fire' does not depend on any axioms\n'Reasoning.Main.Cap.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.firings_bounded' does not depend on any axioms\n'Reasoning.Main.Cap.follow' does not depend on any axioms\n'Reasoning.Main.Cap.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.iterations_bounded' does not depend on any axioms\n'Reasoning.Main.Cap.next' does not depend on any axioms\n'Reasoning.Main.Cap.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.observe' does not depend on any axioms\n'Reasoning.Main.Cap.replay' does not depend on any axioms\n'Reasoning.Main.Cap.replay_fire' does not depend on any axioms\n'Reasoning.Main.Cap.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.run' does not depend on any axioms\n'Reasoning.Main.Cap.run_state' does not depend on any axioms\n'Reasoning.Main.Cap.run_trace' does not depend on any axioms\n'Reasoning.Main.Cap.saturate' does not depend on any axioms\n'Reasoning.Main.Cap.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Cap.select' does not depend on any axioms\n'Reasoning.Main.Cap.start' does not depend on any axioms\n'Reasoning.Main.Cap.step' does not depend on any axioms\n'Reasoning.Main.Cap.step_count' does not depend on any axioms\n'Reasoning.Main.Cap.step_fired' does not depend on any axioms\n'Reasoning.Main.Cap.step_none' does not depend on any axioms\n'Reasoning.Main.Cap.step_some' does not depend on any axioms\n'Reasoning.Main.Cap.step_trace' does not depend on any axioms\n'Reasoning.Main.Cap.verdict' does not depend on any axioms\n'Reasoning.Main.Cap.verdict_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Capped' does not depend on any axioms\n'Reasoning.Main.Ceiling.sound' depends on axioms: [propext]\n'Reasoning.Main.GatewayEvidence.gateway_safe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.GatewayModel' does not depend on any axioms\n'Reasoning.Main.GatewayTriage' does not depend on any axioms\n'Reasoning.Main.Grade' does not depend on any axioms\n'Reasoning.Main.Grade.Ledger' does not depend on any axioms\n'Reasoning.Main.Grade.Run' does not depend on any axioms\n'Reasoning.Main.Grade.Step' does not depend on any axioms\n'Reasoning.Main.Grade.accept' does not depend on any axioms\n'Reasoning.Main.Grade.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.account' does not depend on any axioms\n'Reasoning.Main.Grade.answer' does not depend on any axioms\n'Reasoning.Main.Grade.attempts' does not depend on any axioms\n'Reasoning.Main.Grade.conclude' does not depend on any axioms\n'Reasoning.Main.Grade.conclude_accept' does not depend on any axioms\n'Reasoning.Main.Grade.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.extract' does not depend on any axioms\n'Reasoning.Main.Grade.fire' does not depend on any axioms\n'Reasoning.Main.Grade.fire_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Grade.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.firings_bounded' does not depend on any axioms\n'Reasoning.Main.Grade.follow' does not depend on any axioms\n'Reasoning.Main.Grade.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.iterations_bounded' does not depend on any axioms\n'Reasoning.Main.Grade.next' does not depend on any axioms\n'Reasoning.Main.Grade.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.next_preserves_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.next_progress' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.Grade.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.observe' does not depend on any axioms\n'Reasoning.Main.Grade.replay' does not depend on any axioms\n'Reasoning.Main.Grade.replay_fire' does not depend on any axioms\n'Reasoning.Main.Grade.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.run' does not depend on any axioms\n'Reasoning.Main.Grade.run_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.run_state' does not depend on any axioms\n'Reasoning.Main.Grade.run_trace' does not depend on any axioms\n'Reasoning.Main.Grade.saturate' does not depend on any axioms\n'Reasoning.Main.Grade.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturate_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Grade.select' does not depend on any axioms\n'Reasoning.Main.Grade.start' does not depend on any axioms\n'Reasoning.Main.Grade.step' does not depend on any axioms\n'Reasoning.Main.Grade.step_count' does not depend on any axioms\n'Reasoning.Main.Grade.step_fired' does not depend on any axioms\n'Reasoning.Main.Grade.step_none' does not depend on any axioms\n'Reasoning.Main.Grade.step_some' does not depend on any axioms\n'Reasoning.Main.Grade.step_trace' does not depend on any axioms\n'Reasoning.Main.Grade.verdict' does not depend on any axioms\n'Reasoning.Main.Grade.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.Graded' does not depend on any axioms\n'Reasoning.Main.Guaranteed' does not depend on any axioms\n'Reasoning.Main.Related' does not depend on any axioms\n'Reasoning.Main.Scale.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.cap_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.cappedCheck' does not depend on any axioms\n'Reasoning.Main.capped_sound' depends on axioms: [propext]\n'Reasoning.Main.doseLevel' does not depend on any axioms\n'Reasoning.Main.dose_exhausted' does not depend on any axioms\n'Reasoning.Main.dose_exhausted_ledger' does not depend on any axioms\n'Reasoning.Main.dose_found' does not depend on any axioms\n'Reasoning.Main.dose_ledger' does not depend on any axioms\n'Reasoning.Main.gatewayLevel' does not depend on any axioms\n'Reasoning.Main.gateway_level' does not depend on any axioms\n'Reasoning.Main.gateway_safe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.gradeLevel' does not depend on any axioms\n'Reasoning.Main.grade_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.grade_correct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.grade_ledger' does not depend on any axioms\n'Reasoning.Main.grade_pending' depends on axioms: [propext, Quot.sound]\n'Reasoning.Main.grade_shock' does not depend on any axioms\n'Reasoning.Main.grade_well_ledger' does not depend on any axioms\n'Reasoning.Main.gradedCheck' does not depend on any axioms\n'Reasoning.Main.graded_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.planLeft' depends on axioms: [propext]\n'Reasoning.Main.plan_found' depends on axioms: [propext]\n'Reasoning.Main.plan_frontier' depends on axioms: [propext]\n'Reasoning.Main.plan_ledger' depends on axioms: [propext]\n'Reasoning.Main.plan_unsolved' depends on axioms: [propext]\n'Reasoning.Main.plan_unsolved_ledger' depends on axioms: [propext]\n'Reasoning.Main.refund_drained' does not depend on any axioms\n'Reasoning.Main.refund_ledger' does not depend on any axioms\n'Reasoning.Main.refund_unsolved' does not depend on any axioms\n'Reasoning.Main.refund_unsolved_ledger' does not depend on any axioms\n'Reasoning.Main.related_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.related_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Main.review_exhausted' does not depend on any axioms\n'Reasoning.Main.review_ledger' does not depend on any axioms\n'Reasoning.Main.review_rejected' does not depend on any axioms\n'Reasoning.Main.review_rejected_ledger' does not depend on any axioms\n'Reasoning.Main.screenDose' does not depend on any axioms\n'Reasoning.Main.screen_found' does not depend on any axioms\n'Reasoning.Main.screen_ledger' does not depend on any axioms\n'Reasoning.Main.screen_truncated' does not depend on any axioms\n'Reasoning.Main.screen_truncated_ledger' does not depend on any axioms\n'Reasoning.Main.screen_unsolved_ledger' does not depend on any axioms\n'Reasoning.Main.spendLeft' does not depend on any axioms\n'Reasoning.Main.spend_drained' does not depend on any axioms\n'Reasoning.Main.spend_ledger' does not depend on any axioms\n'Reasoning.Main.triageLevel' does not depend on any axioms\n'Reasoning.Main.triageSteps' does not depend on any axioms\n'Reasoning.Main.triage_forged' does not depend on any axioms\n'Reasoning.Main.triage_inapplicable' does not depend on any axioms\n'Reasoning.Main.triage_iterations' does not depend on any axioms\n'Reasoning.Main.triage_ledger' does not depend on any axioms\n'Reasoning.Main.triage_level' does not depend on any axioms\n'Reasoning.Main.triage_replays' does not depend on any axioms\n'Reasoning.Main.triage_shock' does not depend on any axioms\n'Reasoning.Main.triage_well' does not depend on any axioms\n'Reasoning.Main.triage_well_ledger' does not depend on any axioms\n","stdout_sha256":"13bfab88bf1e8f71fc26deed8cf04a2a08de1934d83603a6cc29cf959867360f","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.process.json similarity index 98% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.process.json index 7edded1f4..6901f2d8f 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Planner","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Planner.Anywhere.sound' depends on axioms: [propext]\n'Reasoning.Planner.EmptyB.apply' does not depend on any axioms\n'Reasoning.Planner.EmptyB.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.EmptyB.conclusion' does not depend on any axioms\n'Reasoning.Planner.EmptyB.guard' does not depend on any axioms\n'Reasoning.Planner.FillA.apply' does not depend on any axioms\n'Reasoning.Planner.FillA.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.FillA.conclusion' does not depend on any axioms\n'Reasoning.Planner.FillA.guard' does not depend on any axioms\n'Reasoning.Planner.Fits' does not depend on any axioms\n'Reasoning.Planner.Held' does not depend on any axioms\n'Reasoning.Planner.Inside.sound' depends on axioms: [propext]\n'Reasoning.Planner.Measured.sound' depends on axioms: [propext]\n'Reasoning.Planner.Measures' does not depend on any axioms\n'Reasoning.Planner.Moves' does not depend on any axioms\n'Reasoning.Planner.Plan' depends on axioms: [propext]\n'Reasoning.Planner.Plan.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.Ledger' does not depend on any axioms\n'Reasoning.Planner.Plan.Node' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.Search' does not depend on any axioms\n'Reasoning.Planner.Plan.Step' does not depend on any axioms\n'Reasoning.Planner.Plan.accept' does not depend on any axioms\n'Reasoning.Planner.Plan.accept_sound' depends on axioms: [propext]\n'Reasoning.Planner.Plan.answer' does not depend on any axioms\n'Reasoning.Planner.Plan.attempts' does not depend on any axioms\n'Reasoning.Planner.Plan.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.explained' depends on axioms: [propext]\n'Reasoning.Planner.Plan.extend' does not depend on any axioms\n'Reasoning.Planner.Plan.extract' does not depend on any axioms\n'Reasoning.Planner.Plan.failure' does not depend on any axioms\n'Reasoning.Planner.Plan.fire' does not depend on any axioms\n'Reasoning.Planner.Plan.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.follow' does not depend on any axioms\n'Reasoning.Planner.Plan.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.fresh' depends on axioms: [propext]\n'Reasoning.Planner.Plan.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.Plan.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.observe' does not depend on any axioms\n'Reasoning.Planner.Plan.replay' does not depend on any axioms\n'Reasoning.Planner.Plan.replay_fire' does not depend on any axioms\n'Reasoning.Planner.Plan.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.run' depends on axioms: [propext]\n'Reasoning.Planner.Plan.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_count' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_step' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.Plan.start' depends on axioms: [propext]\n'Reasoning.Planner.Plan.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.verdict' depends on axioms: [propext]\n'Reasoning.Planner.Plan.verdict_sound' depends on axioms: [propext]\n'Reasoning.Planner.Plan.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFit.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFit.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFit.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFit.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFit.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFit.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFit.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFit.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFit.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFit.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitR.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.explained' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.verdict_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Pour.apply' does not depend on any axioms\n'Reasoning.Planner.Pour.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Pour.candidates' does not depend on any axioms\n'Reasoning.Planner.Pour.conclusion' does not depend on any axioms\n'Reasoning.Planner.Pour.guard' does not depend on any axioms\n'Reasoning.Planner.Pouring.preserves' does not depend on any axioms\n'Reasoning.Planner.Whole' does not depend on any axioms\n'Reasoning.Planner.Within' does not depend on any axioms\n'Reasoning.Planner.empty_jugs_fit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.emptyb_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.filla_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.fits_kept' does not depend on any axioms\n'Reasoning.Planner.held_initial' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.held_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.measuresCheck' does not depend on any axioms\n'Reasoning.Planner.measures_sound' depends on axioms: [propext]\n'Reasoning.Planner.plan_fit_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.plan_held_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.plan_whole_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.pour_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.wholeCheck' does not depend on any axioms\n'Reasoning.Planner.whole_sound' depends on axioms: [propext]\n'Reasoning.Planner.withinCheck' does not depend on any axioms\n'Reasoning.Planner.within_sound' depends on axioms: [propext]\n","stdout_sha256":"1bde3cc2a8f61dcfb844a885ccd0a1c0ee853cf3e237d0038b10dd7f015cf6f3","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Planner","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Planner.Anywhere.sound' depends on axioms: [propext]\n'Reasoning.Planner.EmptyB.apply' does not depend on any axioms\n'Reasoning.Planner.EmptyB.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.EmptyB.conclusion' does not depend on any axioms\n'Reasoning.Planner.EmptyB.guard' does not depend on any axioms\n'Reasoning.Planner.FillA.apply' does not depend on any axioms\n'Reasoning.Planner.FillA.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.FillA.conclusion' does not depend on any axioms\n'Reasoning.Planner.FillA.guard' does not depend on any axioms\n'Reasoning.Planner.Fits' does not depend on any axioms\n'Reasoning.Planner.Held' does not depend on any axioms\n'Reasoning.Planner.Inside.sound' depends on axioms: [propext]\n'Reasoning.Planner.Measured.sound' depends on axioms: [propext]\n'Reasoning.Planner.Measures' does not depend on any axioms\n'Reasoning.Planner.Moves' does not depend on any axioms\n'Reasoning.Planner.Plan' depends on axioms: [propext]\n'Reasoning.Planner.Plan.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.Ledger' does not depend on any axioms\n'Reasoning.Planner.Plan.Node' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.Search' does not depend on any axioms\n'Reasoning.Planner.Plan.Step' does not depend on any axioms\n'Reasoning.Planner.Plan.accept' does not depend on any axioms\n'Reasoning.Planner.Plan.accept_sound' depends on axioms: [propext]\n'Reasoning.Planner.Plan.answer' does not depend on any axioms\n'Reasoning.Planner.Plan.attempts' does not depend on any axioms\n'Reasoning.Planner.Plan.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.explained' depends on axioms: [propext]\n'Reasoning.Planner.Plan.extend' does not depend on any axioms\n'Reasoning.Planner.Plan.extract' does not depend on any axioms\n'Reasoning.Planner.Plan.failure' does not depend on any axioms\n'Reasoning.Planner.Plan.fire' does not depend on any axioms\n'Reasoning.Planner.Plan.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.follow' does not depend on any axioms\n'Reasoning.Planner.Plan.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.fresh' depends on axioms: [propext]\n'Reasoning.Planner.Plan.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.Plan.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.observe' does not depend on any axioms\n'Reasoning.Planner.Plan.replay' does not depend on any axioms\n'Reasoning.Planner.Plan.replay_fire' does not depend on any axioms\n'Reasoning.Planner.Plan.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Plan.run' depends on axioms: [propext]\n'Reasoning.Planner.Plan.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_count' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_step' depends on axioms: [propext]\n'Reasoning.Planner.Plan.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.Plan.start' depends on axioms: [propext]\n'Reasoning.Planner.Plan.successors' does not depend on any axioms\n'Reasoning.Planner.Plan.successors_ok' does not depend on any axioms\n'Reasoning.Planner.Plan.verdict' depends on axioms: [propext]\n'Reasoning.Planner.Plan.verdict_sound' depends on axioms: [propext]\n'Reasoning.Planner.Plan.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFit.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFit.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFit.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFit.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFit.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFit.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFit.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFit.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFit.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFit.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFit.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFit.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFit.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFit.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFit.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFit.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitR.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitR.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitR.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitR.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.EmptyB.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.EmptyB.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.FillA.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.FillA.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Ledger' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Node' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.collect' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Pour.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Search' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.Step' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.accept' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.accept_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.answer' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.attempts' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.expansions_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.explained' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.extend' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.extract' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.failure' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.follow' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.fresh' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.fresh_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.frontier_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.iterations_bounded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.observe' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay_fire' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.PlanFitU.run' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.searchStep' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_count' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_expanded' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_ok' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_peak' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_step' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.search_verify_growth' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.start' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.successors' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.successors_ok' does not depend on any axioms\n'Reasoning.Planner.PlanFitU.verdict' depends on axioms: [propext]\n'Reasoning.Planner.PlanFitU.verdict_sound' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.PlanFitU.verifications_bounded' depends on axioms: [propext]\n'Reasoning.Planner.Pour.apply' does not depend on any axioms\n'Reasoning.Planner.Pour.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.Pour.candidates' does not depend on any axioms\n'Reasoning.Planner.Pour.conclusion' does not depend on any axioms\n'Reasoning.Planner.Pour.guard' does not depend on any axioms\n'Reasoning.Planner.Pouring.preserves' does not depend on any axioms\n'Reasoning.Planner.Whole' does not depend on any axioms\n'Reasoning.Planner.Within' does not depend on any axioms\n'Reasoning.Planner.empty_jugs_fit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.emptyb_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.filla_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.fits_kept' does not depend on any axioms\n'Reasoning.Planner.held_initial' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.held_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.measuresCheck' does not depend on any axioms\n'Reasoning.Planner.measures_sound' depends on axioms: [propext]\n'Reasoning.Planner.plan_fit_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.plan_held_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.plan_whole_correct' depends on axioms: [propext, Quot.sound]\n'Reasoning.Planner.pour_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'Reasoning.Planner.wholeCheck' does not depend on any axioms\n'Reasoning.Planner.whole_sound' depends on axioms: [propext]\n'Reasoning.Planner.withinCheck' does not depend on any axioms\n'Reasoning.Planner.within_sound' depends on axioms: [propext]\n","stdout_sha256":"1bde3cc2a8f61dcfb844a885ccd0a1c0ee853cf3e237d0038b10dd7f015cf6f3","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.lean b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.lean similarity index 100% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.lean rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.lean diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.process.json similarity index 95% rename from examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.process.json rename to examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.process.json index 98abaf60b..a5d3c695f 100644 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.process.json +++ b/examples/reasoning/expected/verify/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.Reasoning.Screening","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Screening.Dose' does not depend on any axioms\n'Reasoning.Screening.Dose.Ledger' does not depend on any axioms\n'Reasoning.Screening.Dose.Step' does not depend on any axioms\n'Reasoning.Screening.Dose.Trial' does not depend on any axioms\n'Reasoning.Screening.Dose.answer' does not depend on any axioms\n'Reasoning.Screening.Dose.candidates' does not depend on any axioms\n'Reasoning.Screening.Dose.explained' depends on axioms: [propext]\n'Reasoning.Screening.Dose.failure' does not depend on any axioms\n'Reasoning.Screening.Dose.run' does not depend on any axioms\n'Reasoning.Screening.Dose.run_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.try' does not depend on any axioms\n'Reasoning.Screening.Dose.try_count' does not depend on any axioms\n'Reasoning.Screening.Dose.try_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.verdict' does not depend on any axioms\n'Reasoning.Screening.Dose.verdict_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.verifications_bounded' does not depend on any axioms\n'Reasoning.Screening.Dose.verify' does not depend on any axioms\n'Reasoning.Screening.Dose.verify_sound' depends on axioms: [propext]\n'Reasoning.Screening.DoseCandidates' does not depend on any axioms\n'Reasoning.Screening.DoseContract.postcondition_sound' depends on axioms: [propext]\n'Reasoning.Screening.DoseModel' does not depend on any axioms\n'Reasoning.Screening.Propose.apply' does not depend on any axioms\n'Reasoning.Screening.Propose.apply_sound' depends on axioms: [propext]\n'Reasoning.Screening.Propose.candidates' does not depend on any axioms\n'Reasoning.Screening.Propose.conclusion' does not depend on any axioms\n'Reasoning.Screening.Propose.guard' does not depend on any axioms\n'Reasoning.Screening.Proposed' does not depend on any axioms\n'Reasoning.Screening.Safe' does not depend on any axioms\n'Reasoning.Screening.SafeDose.sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen' does not depend on any axioms\n'Reasoning.Screening.Screen.Ledger' does not depend on any axioms\n'Reasoning.Screening.Screen.Node' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.collect' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.successors' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.successors_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.Search' does not depend on any axioms\n'Reasoning.Screening.Screen.Step' does not depend on any axioms\n'Reasoning.Screening.Screen.accept' does not depend on any axioms\n'Reasoning.Screening.Screen.accept_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.answer' does not depend on any axioms\n'Reasoning.Screening.Screen.attempts' does not depend on any axioms\n'Reasoning.Screening.Screen.derivation' depends on axioms: [propext]\n'Reasoning.Screening.Screen.expansions_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.explained' depends on axioms: [propext]\n'Reasoning.Screening.Screen.extend' does not depend on any axioms\n'Reasoning.Screening.Screen.extract' does not depend on any axioms\n'Reasoning.Screening.Screen.failure' does not depend on any axioms\n'Reasoning.Screening.Screen.fire' does not depend on any axioms\n'Reasoning.Screening.Screen.fire_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.follow' does not depend on any axioms\n'Reasoning.Screening.Screen.frontier_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.iterations_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.observe' does not depend on any axioms\n'Reasoning.Screening.Screen.replay' does not depend on any axioms\n'Reasoning.Screening.Screen.replay_fire' does not depend on any axioms\n'Reasoning.Screening.Screen.replay_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.run' does not depend on any axioms\n'Reasoning.Screening.Screen.searchStep' does not depend on any axioms\n'Reasoning.Screening.Screen.search_count' does not depend on any axioms\n'Reasoning.Screening.Screen.search_expanded' does not depend on any axioms\n'Reasoning.Screening.Screen.search_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.search_peak' does not depend on any axioms\n'Reasoning.Screening.Screen.search_step' does not depend on any axioms\n'Reasoning.Screening.Screen.search_verify_growth' does not depend on any axioms\n'Reasoning.Screening.Screen.start' does not depend on any axioms\n'Reasoning.Screening.Screen.successors' does not depend on any axioms\n'Reasoning.Screening.Screen.successors_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.verdict' does not depend on any axioms\n'Reasoning.Screening.Screen.verdict_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.verifications_bounded' does not depend on any axioms\n'Reasoning.Screening.Short' does not depend on any axioms\n'Reasoning.Screening.propose_sound' depends on axioms: [propext]\n'Reasoning.Screening.safeCheck' does not depend on any axioms\n'Reasoning.Screening.safe_sound' depends on axioms: [propext]\n'Reasoning.Screening.shortCheck' does not depend on any axioms\n'Reasoning.Screening.short_sound' depends on axioms: [propext]\n","stdout_sha256":"cf0950a5981076ee37dfdf563d46105dc9dbe4ef7ca4ebdbbbc5af2f23a3410b","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A02b315b69b8881ec6f91f78f9b12c608.Reasoning.Screening","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Reasoning.Screening.Dose' does not depend on any axioms\n'Reasoning.Screening.Dose.Ledger' does not depend on any axioms\n'Reasoning.Screening.Dose.Step' does not depend on any axioms\n'Reasoning.Screening.Dose.Trial' does not depend on any axioms\n'Reasoning.Screening.Dose.answer' does not depend on any axioms\n'Reasoning.Screening.Dose.candidates' does not depend on any axioms\n'Reasoning.Screening.Dose.explained' depends on axioms: [propext]\n'Reasoning.Screening.Dose.failure' does not depend on any axioms\n'Reasoning.Screening.Dose.run' does not depend on any axioms\n'Reasoning.Screening.Dose.run_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.try' does not depend on any axioms\n'Reasoning.Screening.Dose.try_count' does not depend on any axioms\n'Reasoning.Screening.Dose.try_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.verdict' does not depend on any axioms\n'Reasoning.Screening.Dose.verdict_sound' depends on axioms: [propext]\n'Reasoning.Screening.Dose.verifications_bounded' does not depend on any axioms\n'Reasoning.Screening.Dose.verify' does not depend on any axioms\n'Reasoning.Screening.Dose.verify_sound' depends on axioms: [propext]\n'Reasoning.Screening.DoseCandidates' does not depend on any axioms\n'Reasoning.Screening.DoseContract.postcondition_sound' depends on axioms: [propext]\n'Reasoning.Screening.DoseModel' does not depend on any axioms\n'Reasoning.Screening.Propose.apply' does not depend on any axioms\n'Reasoning.Screening.Propose.apply_sound' depends on axioms: [propext]\n'Reasoning.Screening.Propose.candidates' does not depend on any axioms\n'Reasoning.Screening.Propose.conclusion' does not depend on any axioms\n'Reasoning.Screening.Propose.guard' does not depend on any axioms\n'Reasoning.Screening.Proposed' does not depend on any axioms\n'Reasoning.Screening.Safe' does not depend on any axioms\n'Reasoning.Screening.SafeDose.sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen' does not depend on any axioms\n'Reasoning.Screening.Screen.Ledger' does not depend on any axioms\n'Reasoning.Screening.Screen.Node' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.collect' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.successors' does not depend on any axioms\n'Reasoning.Screening.Screen.Propose.successors_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.Search' does not depend on any axioms\n'Reasoning.Screening.Screen.Step' does not depend on any axioms\n'Reasoning.Screening.Screen.accept' does not depend on any axioms\n'Reasoning.Screening.Screen.accept_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.answer' does not depend on any axioms\n'Reasoning.Screening.Screen.attempts' does not depend on any axioms\n'Reasoning.Screening.Screen.derivation' depends on axioms: [propext]\n'Reasoning.Screening.Screen.expansions_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.explained' depends on axioms: [propext]\n'Reasoning.Screening.Screen.extend' does not depend on any axioms\n'Reasoning.Screening.Screen.extract' does not depend on any axioms\n'Reasoning.Screening.Screen.failure' does not depend on any axioms\n'Reasoning.Screening.Screen.fire' does not depend on any axioms\n'Reasoning.Screening.Screen.fire_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.follow' does not depend on any axioms\n'Reasoning.Screening.Screen.frontier_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.iterations_bounded' does not depend on any axioms\n'Reasoning.Screening.Screen.observe' does not depend on any axioms\n'Reasoning.Screening.Screen.replay' does not depend on any axioms\n'Reasoning.Screening.Screen.replay_fire' does not depend on any axioms\n'Reasoning.Screening.Screen.replay_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.run' does not depend on any axioms\n'Reasoning.Screening.Screen.searchStep' does not depend on any axioms\n'Reasoning.Screening.Screen.search_count' does not depend on any axioms\n'Reasoning.Screening.Screen.search_expanded' does not depend on any axioms\n'Reasoning.Screening.Screen.search_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.search_peak' does not depend on any axioms\n'Reasoning.Screening.Screen.search_step' does not depend on any axioms\n'Reasoning.Screening.Screen.search_verify_growth' does not depend on any axioms\n'Reasoning.Screening.Screen.start' does not depend on any axioms\n'Reasoning.Screening.Screen.successors' does not depend on any axioms\n'Reasoning.Screening.Screen.successors_ok' does not depend on any axioms\n'Reasoning.Screening.Screen.verdict' does not depend on any axioms\n'Reasoning.Screening.Screen.verdict_sound' depends on axioms: [propext]\n'Reasoning.Screening.Screen.verifications_bounded' does not depend on any axioms\n'Reasoning.Screening.Short' does not depend on any axioms\n'Reasoning.Screening.propose_sound' depends on axioms: [propext]\n'Reasoning.Screening.safeCheck' does not depend on any axioms\n'Reasoning.Screening.safe_sound' depends on axioms: [propext]\n'Reasoning.Screening.shortCheck' does not depend on any axioms\n'Reasoning.Screening.short_sound' depends on axioms: [propext]\n","stdout_sha256":"cf0950a5981076ee37dfdf563d46105dc9dbe4ef7ca4ebdbbbc5af2f23a3410b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.process.json deleted file mode 100644 index a0edc8afc..000000000 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.process.json deleted file mode 100644 index c434694f3..000000000 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.process.json b/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.process.json deleted file mode 100644 index c81de023b..000000000 --- a/examples/reasoning/expected/verify/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A7b45b58d681c076cfd69727310b65f3f.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/reasoning/expected/verify/extract/LexLeanExtract.X7b45b58d681c076cfd69727310b65f3f.lean b/examples/reasoning/expected/verify/extract/LexLeanExtract.X02b315b69b8881ec6f91f78f9b12c608.lean similarity index 100% rename from examples/reasoning/expected/verify/extract/LexLeanExtract.X7b45b58d681c076cfd69727310b65f3f.lean rename to examples/reasoning/expected/verify/extract/LexLeanExtract.X02b315b69b8881ec6f91f78f9b12c608.lean diff --git a/examples/reasoning/expected/verify/extract/process.json b/examples/reasoning/expected/verify/extract/process.json index d8ee4897a..5bd0fa215 100644 --- a/examples/reasoning/expected/verify/extract/process.json +++ b/examples/reasoning/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X7b45b58d681c076cfd69727310b65f3f.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X7b45b58d681c076cfd69727310b65f3f","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Reasoning.Main.triageLevel\",\"Reasoning.Main.gatewayLevel\",\"Reasoning.Main.triageSteps\",\"Reasoning.Main.planLeft\",\"Reasoning.Main.doseLevel\",\"Reasoning.Main.gradeLevel\",\"Reasoning.Main.screenDose\",\"Reasoning.Main.spendLeft\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.containsElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.containsElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}},\"uses\":[\"Bool\",\"List\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOrdNat\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"instOrdNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyProd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"Prod.fst\",\"Prod.snd\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.Key.mk\",\"LexLeanCollections.compareCodes.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},\"uses\":[\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.compareCodes._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Ordering.casesOn\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.emptyCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.beq\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.beq\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Chart.mk\",\"parameters\":0,\"fields\":9,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}}}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.match_1\",\"Reasoning.Clinic.Triage.run\",\"Reasoning.Clinic.Triage.Run.state\",\"Reasoning.Clinic.Triage.Run.trace\",\"Reasoning.Clinic.Triage.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":1,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.92\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Vitals.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.feverish\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.temperature\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"380\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.hypotensive\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.systolic\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":4,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.leukocytic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.whiteCells\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"12\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":3,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.recommendationCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Bool.not\",\"Bool.or\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.tachycardic\",\"Reasoning.Clinic.Vitals.infection\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.176\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.84\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachycardic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.feverish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":5,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.133\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.135\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.hypotensive\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.154\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.157\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.147\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.160\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.168\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.170\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.174\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.183\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.185\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.187\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.189\"}}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.tachycardic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.tachycardic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.heartRate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.tachypneic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.respiratoryRate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":2,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.GatewayModel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayTriage\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.GatewayTriage\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayTriage\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.GatewayTriage\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.doseLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Screening.Dose.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Dose.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.gatewayLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.GatewayModel\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.GatewayModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayModel\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.gradeLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Main.Grade.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.planLeft\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.fst\",\"Reasoning.Main.planLeft.match_1\",\"Reasoning.Planner.Plan.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.screenDose\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Screening.Screen.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.spendLeft\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Reasoning.Budget.Spend.verdict\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Budget.Spend.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.triageLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Triage.verdict\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.triageSteps\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"OfNat.ofNat\",\"Prod.snd\",\"Reasoning.Clinic.Triage\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.triageSteps.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.92\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Clinic.Triage\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.failure\",\"Reasoning.Planner.Plan.run\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Search.found\",\"Reasoning.Planner.Plan.Search.truncated\",\"Reasoning.Planner.Plan.searchStep.match_5\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":2,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.failure\",\"Reasoning.Planner.Plan.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.measuresCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.DoseCandidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"30\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"50\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.DoseModel\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.DoseCandidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseCandidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Nat\",\"Reasoning.Screening.DoseCandidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.failure\",\"Reasoning.Screening.Screen.run\",\"Reasoning.Screening.Screen.Node.trace\",\"Reasoning.Screening.Screen.Search.found\",\"Reasoning.Screening.Screen.Search.truncated\",\"Reasoning.Screening.Screen.searchStep.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":1,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.failure\",\"Reasoning.Screening.Screen.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.safeCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.shortCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.conclusion\",\"Reasoning.Budget.Burn.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.conclusion\",\"Reasoning.Budget.Burn.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}}}}}},\"uses\":[\"Nat\",\"Prod\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"parameters\":1,\"fields\":0,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}}},{\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"Reasoning.Budget.Spend.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.emptyCheck\",\"Reasoning.Budget.Spend.extract\",\"Reasoning.Budget.Spend.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.emptyCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.emptyCheck\",\"Reasoning.Budget.Spend.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Budget.Spend.accept\",\"Reasoning.Budget.Spend.extract\",\"Reasoning.Budget.Spend.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Budget.Spend.accept\",\"Reasoning.Budget.Spend.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Option.some\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Reasoning.Budget.Burn.apply\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.apply\",\"Reasoning.Budget.Spend.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Budget.Spend.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.38\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Budget.Spend.Step.Tick\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Budget.Spend.Step.Burn\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}]}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Unit.unit\",\"Reasoning.Budget.Burn.apply\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.apply\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.none\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.fire\",\"Reasoning.Budget.Spend.select\",\"Reasoning.Budget.Spend.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.select\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}]}}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.fire\",\"Reasoning.Budget.Spend.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Prod.snd\",\"Reasoning.Budget.Spend.next\",\"Reasoning.Budget.Spend.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.next\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Budget.Spend.next\",\"Reasoning.Budget.Spend.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.listFold\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.candidates\",\"Reasoning.Budget.Burn.guard\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.guard\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}}},\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.141\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Burn.candidates\",\"Reasoning.Budget.Burn.guard\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.guard\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Budget.Spend.conclude\",\"Reasoning.Budget.Spend.saturate\",\"Reasoning.Budget.Spend.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Budget.Spend.conclude\",\"Reasoning.Budget.Spend.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Tick.conclusion\",\"Reasoning.Budget.Tick.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Tick.conclusion\",\"Reasoning.Budget.Tick.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Nat.blt\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.fever\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.leukocytosis\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.level\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.sepsis\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.shock\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.sirs\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.tachycardia\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.tachypnea\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.vitals\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.conclusion\",\"Reasoning.Clinic.Escalate.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.conclusion\",\"Reasoning.Clinic.Escalate.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Bool.or\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.219\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.86\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.174\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.146\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.143\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.154\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.167\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.161\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.156\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.170\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.173\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}}]}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.191\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.188\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.191\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.199\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.212\",\"parameters\":[{\"id\":\"_uniq.206\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.206\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.175\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.209\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.215\",\"parameters\":[{\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.212\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.218\",\"parameters\":[{\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.216\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.212\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.215\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.218\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]}}}]}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.219\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.227\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.225\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.229\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.231\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.220\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.233\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.blt\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Fever.conclusion\",\"Reasoning.Clinic.Fever.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Fever.conclusion\",\"Reasoning.Clinic.Fever.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.feverish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Leukocytosis.conclusion\",\"Reasoning.Clinic.Leukocytosis.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Leukocytosis.conclusion\",\"Reasoning.Clinic.Leukocytosis.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.leukocytic\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.leukocytic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.leukocytic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sepsis.conclusion\",\"Reasoning.Clinic.Sepsis.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sepsis.conclusion\",\"Reasoning.Clinic.Sepsis.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.vitals\",\"Reasoning.Clinic.Vitals.infection\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":5,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.65\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.81\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Shock.conclusion\",\"Reasoning.Clinic.Shock.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Shock.conclusion\",\"Reasoning.Clinic.Shock.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.hypotensive\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.hypotensive\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sirs.conclusion\",\"Reasoning.Clinic.Sirs.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sirs.conclusion\",\"Reasoning.Clinic.Sirs.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.and\",\"HAdd.hAdd\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}]}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachycardia.conclusion\",\"Reasoning.Clinic.Tachycardia.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachycardia.conclusion\",\"Reasoning.Clinic.Tachycardia.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.tachycardic\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachycardic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.tachycardic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachypnea.conclusion\",\"Reasoning.Clinic.Tachypnea.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachypnea.conclusion\",\"Reasoning.Clinic.Tachypnea.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.tachypneic\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachypneic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.tachypneic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage.Run\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]}},{\"name\":\"Reasoning.Clinic.Triage.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.recommendationCheck\",\"Reasoning.Clinic.Triage.extract\",\"Reasoning.Clinic.Triage.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.recommendationCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.recommendationCheck\",\"Reasoning.Clinic.Triage.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.245\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.244\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.243\",\"parameters\":[{\"id\":\"_uniq.241\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.241\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.242\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.142\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.239\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.175\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.184\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.238\",\"parameters\":[{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.228\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.233\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"},{\"kind\":\"fvar\",\"id\":\"_uniq.235\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.243\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.237\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.185\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.200\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.226\",\"parameters\":[{\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.216\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.220\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.175\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.221\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.222\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.238\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.205\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.206\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.209\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.206\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"},{\"kind\":\"fvar\",\"id\":\"_uniq.212\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.207\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.227\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.238\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.159\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.164\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.164\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.240\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.243\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.123\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.244\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.112\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.244\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.245\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.245\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.accept\",\"Reasoning.Clinic.Triage.extract\",\"Reasoning.Clinic.Triage.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.accept\",\"Reasoning.Clinic.Triage.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}},\"uses\":[\"Nat\",\"Option\",\"Option.some\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Clinic.Triage.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Fever\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Shock\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.none\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}]}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.start\",\"Reasoning.Clinic.Triage.step\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.step\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.start\",\"Reasoning.Clinic.Triage.step\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.next\",\"Reasoning.Clinic.Triage.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.next\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.next\",\"Reasoning.Clinic.Triage.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.273\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.196\",\"parameters\":[{\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.190\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.184\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.197\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.229\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.220\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.222\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.225\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.227\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.272\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.265\",\"parameters\":[{\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.259\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.198\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.260\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.261\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.262\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.263\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.271\",\"parameters\":[{\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.268\",\"parameters\":[{\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.230\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.254\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.268\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.271\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.248\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.251\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.273\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.348\",\"parameters\":[{\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.316\",\"parameters\":[{\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.307\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"},{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.309\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.310\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.311\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.312\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.313\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.314\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.317\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.316\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.334\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.335\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.333\"},{\"kind\":\"fvar\",\"id\":\"_uniq.334\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.347\",\"parameters\":[{\"id\":\"_uniq.341\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.341\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.342\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.343\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.317\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.342\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.343\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.344\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.345\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.344\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.345\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.335\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.336\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.338\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.339\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.340\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.349\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.348\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.362\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.382\",\"parameters\":[{\"id\":\"_uniq.364\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.373\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.374\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.375\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.373\"},{\"kind\":\"fvar\",\"id\":\"_uniq.374\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.375\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.376\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.377\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.377\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.378\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.379\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.380\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.379\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.380\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.382\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.401\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.400\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.437\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.430\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.423\",\"parameters\":[{\"id\":\"_uniq.417\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.417\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.274\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.418\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.420\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.421\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.420\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.421\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.426\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.425\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.349\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.424\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.425\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.429\",\"parameters\":[{\"id\":\"_uniq.427\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.428\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.427\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.428\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.412\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.426\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.429\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.415\"}]}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.436\",\"parameters\":[{\"id\":\"_uniq.434\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.435\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.362\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.434\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.435\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.433\",\"parameters\":[{\"id\":\"_uniq.431\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.432\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.383\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.431\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.432\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.407\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.408\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.433\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.408\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.436\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.401\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.402\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.403\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.403\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.404\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.405\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.406\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.405\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.406\"}]}}}}]}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"List.nil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.observe\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"List.nil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Ledger\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.observe\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.step\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.attempts\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.Ledger.attempts\",\"Reasoning.Clinic.Triage.Ledger.expansions\",\"Reasoning.Clinic.Triage.Ledger.firings\",\"Reasoning.Clinic.Triage.Ledger.frontier\",\"Reasoning.Clinic.Triage.Ledger.iterations\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Ledger.verifications\",\"Reasoning.Clinic.Triage.Run.ledger\",\"Reasoning.Clinic.Triage.Run.mk\",\"Reasoning.Clinic.Triage.Run.state\",\"Reasoning.Clinic.Triage.Run.trace\",\"Reasoning.Clinic.Triage.next.match_1\",\"Reasoning.Clinic.Triage.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":2,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":0,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":1,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":2,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":3,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":4,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":5,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}]}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Ledger\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.attempts\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.saturate\",\"Reasoning.Clinic.Triage.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.56\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.heartRate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.infection\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.respiratoryRate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.systolic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.temperature\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.whiteCells\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]}},{\"name\":\"Reasoning.Main.Grade.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.extract\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"uses\":[\"Nat\",\"Option\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.accept\",\"Reasoning.Main.Grade.extract\",\"Reasoning.Main.Grade.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.accept\",\"Reasoning.Main.Grade.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Nat\",\"Option\",\"Option.some\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Main.Grade.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Fever\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Sirs\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Sepsis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Shock\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Escalate\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.none\",\"Reasoning.Clinic.Chart\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire\",\"Reasoning.Main.Grade.select\",\"Reasoning.Main.Grade.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}]}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire\",\"Reasoning.Main.Grade.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.next\",\"Reasoning.Main.Grade.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.next\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.next\",\"Reasoning.Main.Grade.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.273\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.196\",\"parameters\":[{\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.190\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.184\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.197\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.229\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.220\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.222\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.225\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.227\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.272\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.265\",\"parameters\":[{\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.259\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.198\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.260\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.261\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.262\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.263\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.271\",\"parameters\":[{\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.268\",\"parameters\":[{\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.230\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.254\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.268\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.271\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.248\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.251\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.273\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.348\",\"parameters\":[{\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.316\",\"parameters\":[{\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.307\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"},{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.309\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.310\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.311\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.312\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.313\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.314\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.317\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.316\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.334\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.335\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.333\"},{\"kind\":\"fvar\",\"id\":\"_uniq.334\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.347\",\"parameters\":[{\"id\":\"_uniq.341\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.341\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.342\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.343\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.317\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.342\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.343\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.344\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.345\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.344\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.345\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.335\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.336\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.338\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.339\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.340\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.349\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.348\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.362\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.382\",\"parameters\":[{\"id\":\"_uniq.364\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.373\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.374\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.375\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.373\"},{\"kind\":\"fvar\",\"id\":\"_uniq.374\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.375\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.376\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.377\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.377\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.378\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.379\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.380\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.379\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.380\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.382\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.401\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.400\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.437\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.430\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.423\",\"parameters\":[{\"id\":\"_uniq.417\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.417\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.274\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.418\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.420\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.421\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.420\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.421\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.426\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.425\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.349\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.424\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.425\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.429\",\"parameters\":[{\"id\":\"_uniq.427\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.428\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.427\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.428\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.412\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.426\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.429\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.415\"}]}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.436\",\"parameters\":[{\"id\":\"_uniq.434\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.435\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.362\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.434\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.435\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.433\",\"parameters\":[{\"id\":\"_uniq.431\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.432\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.383\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.431\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.432\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.407\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.408\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.433\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.408\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.436\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.401\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.402\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.403\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.403\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.404\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.405\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.406\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.405\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.406\"}]}}}}]}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.conclude\",\"Reasoning.Main.Grade.saturate\",\"Reasoning.Main.Grade.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.50\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.conclude\",\"Reasoning.Main.Grade.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.planLeft.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.triageSteps.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.EmptyB.conclusion\",\"Reasoning.Planner.EmptyB.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.EmptyB.conclusion\",\"Reasoning.Planner.EmptyB.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.FillA.conclusion\",\"Reasoning.Planner.FillA.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.FillA.conclusion\",\"Reasoning.Planner.FillA.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Node\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Search\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"parameters\":0,\"fields\":5,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}}}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}}]}},{\"name\":\"Reasoning.Planner.Plan.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.measuresCheck\",\"Reasoning.Planner.Plan.extract\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.measuresCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.measuresCheck\",\"Reasoning.Planner.Plan.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"OfNat.ofNat\",\"Reasoning.Planner.Pour.candidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Planner.Pour.candidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.and\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Reasoning.Planner.EmptyB.apply\",\"Reasoning.Planner.FillA.apply\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Pour.apply\",\"Reasoning.Planner.Plan.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Planner.Plan.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.FillA\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.Pour\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Unit.unit\",\"Reasoning.Planner.EmptyB.apply\",\"Reasoning.Planner.FillA.apply\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Pour.apply\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fresh\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Node.state\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.36\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Reasoning.Planner.Plan.Node\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.searchStep\",\"Reasoning.Planner.Plan.start\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.searchStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}}}},\"uses\":[\"Bool\",\"Mul\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instMulNat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.multiply\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.searchStep\",\"Reasoning.Planner.Plan.start\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.accept\",\"Reasoning.Planner.Plan.attempts\",\"Reasoning.Planner.Plan.fresh\",\"Reasoning.Planner.Plan.successors\",\"Reasoning.Planner.Plan.Ledger.attempts\",\"Reasoning.Planner.Plan.Ledger.expansions\",\"Reasoning.Planner.Plan.Ledger.firings\",\"Reasoning.Planner.Plan.Ledger.frontier\",\"Reasoning.Planner.Plan.Ledger.iterations\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Ledger.verifications\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Search.found\",\"Reasoning.Planner.Plan.Search.frontier\",\"Reasoning.Planner.Plan.Search.ledger\",\"Reasoning.Planner.Plan.Search.mk\",\"Reasoning.Planner.Plan.Search.truncated\",\"Reasoning.Planner.Plan.Search.visited\",\"Reasoning.Planner.Plan.searchStep.match_1\",\"Reasoning.Planner.Plan.searchStep.match_3\",\"Reasoning.Planner.Plan.searchStep.match_5\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.327\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.310\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.139\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":4,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":0,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.150\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":1,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":2,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":3,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":4,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":5,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.294\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fresh\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.179\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.181\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.210\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.198\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.199\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.203\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.205\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.179\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.210\"},{\"kind\":\"fvar\",\"id\":\"_uniq.211\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.212\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.223\",\"parameters\":[{\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.222\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.223\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.234\",\"parameters\":[{\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.228\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.233\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.234\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.240\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.287\",\"parameters\":[{\"id\":\"_uniq.245\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.247\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":4,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":0,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.251\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.252\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":1,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.256\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"},{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":2,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.260\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.259\"},{\"kind\":\"fvar\",\"id\":\"_uniq.261\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":3,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.264\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.263\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.265\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":4,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.265\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.275\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":5,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.260\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.275\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.279\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.277\"},{\"kind\":\"fvar\",\"id\":\"_uniq.278\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.286\",\"parameters\":[{\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.283\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.254\"},{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.262\"},{\"kind\":\"fvar\",\"id\":\"_uniq.264\"},{\"kind\":\"fvar\",\"id\":\"_uniq.266\"},{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.245\"},{\"kind\":\"fvar\",\"id\":\"_uniq.283\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.285\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.279\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.280\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.275\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.281\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.293\",\"parameters\":[{\"id\":\"_uniq.291\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.224\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.291\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.292\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.290\",\"parameters\":[{\"id\":\"_uniq.288\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.289\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.235\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.288\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.289\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.240\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.290\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.241\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.243\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.295\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.294\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.303\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.303\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.304\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.305\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.306\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.295\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.305\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.306\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.307\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.308\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.310\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.320\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.320\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.321\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.322\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.321\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.322\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.323\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.324\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.325\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.311\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.323\"},{\"kind\":\"fvar\",\"id\":\"_uniq.324\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.325\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.328\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.327\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.336\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.336\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.338\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.328\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.338\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.339\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.340\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Planner.Plan.Ledger\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.accept\",\"Reasoning.Planner.Plan.attempts\",\"Reasoning.Planner.Plan.fresh\",\"Reasoning.Planner.Plan.successors\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.observe\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Search.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.65\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Reasoning.Planner.Plan.Ledger\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.observe\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.EmptyB.successors\",\"Reasoning.Planner.Plan.FillA.successors\",\"Reasoning.Planner.Plan.Pour.successors\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.FillA.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.EmptyB.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Pour.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.EmptyB.successors\",\"Reasoning.Planner.Plan.FillA.successors\",\"Reasoning.Planner.Plan.Pour.successors\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Reasoning.Planner.Plan\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.verdict.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan\",\"Reasoning.Planner.Plan.Step\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.Pour.conclusion\",\"Reasoning.Planner.Pour.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.Pour.conclusion\",\"Reasoning.Planner.Pour.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.and\",\"HAdd.hAdd\",\"Nat.ble\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.90\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}]}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Screening.Dose.Trial\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}}}}]}},{\"name\":\"Reasoning.Screening.Dose.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\",\"Reasoning.Screening.Propose.candidates.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.shortCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.84\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.78\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]}}}]}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.mk\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.Ledger.verifications\",\"Reasoning.Screening.Dose.Trial.ledger\",\"Reasoning.Screening.Dose.Trial.truncated\",\"Reasoning.Screening.Dose.try.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.93\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.false\",\"LexLeanCollections.listFold\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.candidates\",\"Reasoning.Screening.Dose.try\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.13\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.try\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"instOfNatNat\",\"Bool.false\",\"LexLeanCollections.listFold\",\"Option.none\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.candidates\",\"Reasoning.Screening.Dose.try\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"HAdd.hAdd\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.verify\",\"Reasoning.Screening.Dose.Ledger.attempts\",\"Reasoning.Screening.Dose.Ledger.expansions\",\"Reasoning.Screening.Dose.Ledger.firings\",\"Reasoning.Screening.Dose.Ledger.frontier\",\"Reasoning.Screening.Dose.Ledger.iterations\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Ledger.verifications\",\"Reasoning.Screening.Dose.Trial.found\",\"Reasoning.Screening.Dose.Trial.ledger\",\"Reasoning.Screening.Dose.Trial.mk\",\"Reasoning.Screening.Dose.Trial.truncated\",\"Reasoning.Screening.Dose.try.match_1\",\"Reasoning.Screening.Dose.try.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.verify\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":1,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":1,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":2,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":3,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":5,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.102\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.verify\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.failure\",\"Reasoning.Screening.Dose.run\",\"Reasoning.Screening.Dose.Trial.found\",\"Reasoning.Screening.Dose.try.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.failure\",\"Reasoning.Screening.Dose.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.verify\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.safeCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.Propose.conclusion\",\"Reasoning.Screening.Propose.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.Propose.conclusion\",\"Reasoning.Screening.Propose.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\",\"Reasoning.Screening.Propose.candidates.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.shortCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]}}}]}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Prod.fst\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Nat\",\"Prod\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Node\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Search\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"parameters\":0,\"fields\":4,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}}]}},{\"name\":\"Reasoning.Screening.Screen.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\",\"Reasoning.Screening.Screen.extract\",\"Reasoning.Screening.Screen.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.safeCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.safeCheck\",\"Reasoning.Screening.Screen.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Screening.Propose.candidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Screening.Propose.candidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Nat.blt\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.and\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Reasoning.Screening.Propose.apply\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.31\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Screening.Screen.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Screening.Screen.Step.Propose\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}]}}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Reasoning.Screening.Propose.apply\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.searchStep\",\"Reasoning.Screening.Screen.start\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.searchStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.searchStep\",\"Reasoning.Screening.Screen.start\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.accept\",\"Reasoning.Screening.Screen.attempts\",\"Reasoning.Screening.Screen.successors\",\"Reasoning.Screening.Dose.try.match_3\",\"Reasoning.Screening.Screen.Ledger.attempts\",\"Reasoning.Screening.Screen.Ledger.expansions\",\"Reasoning.Screening.Screen.Ledger.firings\",\"Reasoning.Screening.Screen.Ledger.frontier\",\"Reasoning.Screening.Screen.Ledger.iterations\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Ledger.verifications\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Search.found\",\"Reasoning.Screening.Screen.Search.frontier\",\"Reasoning.Screening.Screen.Search.ledger\",\"Reasoning.Screening.Screen.Search.mk\",\"Reasoning.Screening.Screen.Search.truncated\",\"Reasoning.Screening.Screen.searchStep.match_1\",\"Reasoning.Screening.Screen.searchStep.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.320\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.303\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.138\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":0,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":1,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":2,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":3,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":4,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":5,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.287\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.205\",\"parameters\":[{\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.194\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.198\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.199\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.181\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.200\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.205\"},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.217\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.227\",\"parameters\":[{\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.222\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.223\"},{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.226\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.227\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.280\",\"parameters\":[{\"id\":\"_uniq.238\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.240\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.239\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.240\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":0,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.243\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":1,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.249\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.248\"},{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":2,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.252\"},{\"kind\":\"fvar\",\"id\":\"_uniq.254\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":3,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.256\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":4,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":5,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.268\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"},{\"kind\":\"fvar\",\"id\":\"_uniq.271\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.279\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.247\"},{\"kind\":\"fvar\",\"id\":\"_uniq.251\"},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"},{\"kind\":\"fvar\",\"id\":\"_uniq.257\"},{\"kind\":\"fvar\",\"id\":\"_uniq.259\"},{\"kind\":\"fvar\",\"id\":\"_uniq.275\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.208\"},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.238\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.277\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.278\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.272\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.273\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.279\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.268\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.274\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.279\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.286\",\"parameters\":[{\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.218\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.280\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.285\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.283\",\"parameters\":[{\"id\":\"_uniq.281\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.228\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.281\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.280\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.233\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.283\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.288\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.297\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.296\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.297\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.299\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.288\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.298\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.299\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.300\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.301\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.300\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.301\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.303\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.313\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.315\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.314\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.315\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.316\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.317\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.318\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.304\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.316\"},{\"kind\":\"fvar\",\"id\":\"_uniq.317\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.318\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.321\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.320\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.329\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.329\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.330\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.331\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.321\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.330\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.331\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.332\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.332\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.333\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Screen.Ledger\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.accept\",\"Reasoning.Screening.Screen.attempts\",\"Reasoning.Screening.Screen.successors\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.observe\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Search.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.59\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Reasoning.Screening.Screen.Ledger\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.observe\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.successors\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Propose.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.successors\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Reasoning.Screening.Screen\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.verdict.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen\",\"Reasoning.Screening.Screen.Step\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"kind\":\"constructor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"kind\":\"constructor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.EmptyB.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.EmptyB\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.FillA.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.FillA\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Pour.collect\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.Pour\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Pour.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Pour.candidates\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Pour.collect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Pour.collect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Pour.candidates\",\"Reasoning.Planner.Plan.Pour.collect\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.visited\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_5\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.verdict.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.candidates.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Propose.collect\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Node.trace\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Step.Propose\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Propose.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Screening.Propose.candidates\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Propose.collect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Propose.collect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Screening.Propose.candidates\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.collect\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.verdict.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen.Step\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.eq\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.gt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"d2c9b0ff12d25eb940a8ff94fdbfcd8794392d439e10d7eaa35eefbe43ed2b4b","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X02b315b69b8881ec6f91f78f9b12c608.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X02b315b69b8881ec6f91f78f9b12c608","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"Reasoning.Main.triageLevel\",\"Reasoning.Main.gatewayLevel\",\"Reasoning.Main.triageSteps\",\"Reasoning.Main.planLeft\",\"Reasoning.Main.doseLevel\",\"Reasoning.Main.gradeLevel\",\"Reasoning.Main.screenDose\",\"Reasoning.Main.spendLeft\"],\"constants\":[{\"name\":\"LexLeanCollections.Key\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanCollections.Key.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanCollections.containsElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.containsElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.94\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.99\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.107\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},\"borrow\":false},{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}},\"uses\":[\"Bool\",\"List\",\"Ordering\",\"PUnit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"List.brecOn\",\"LexLeanCollections.insertElement._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.123\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.lt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Ordering.gt\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},\"borrow\":false},{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}]}}}}}},\"uses\":[\"List\",\"Ordering\",\"PUnit\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\",\"List.cons\",\"List.nil\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOrdNat\",\"Ord.compare\",\"LexLeanCollections.Key.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instOrdNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.1\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}}},\"uses\":[\"Nat\",\"Ord\",\"Ordering\",\"instOrdNat\",\"LexLeanCollections.Key\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.instKeyProd\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Prod\",\"Unit\",\"LexLeanCollections.Key\",\"Prod.fst\",\"Prod.snd\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.Key.mk\",\"LexLeanCollections.compareCodes.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"bvar\",\"index\":2}]}]}}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.82\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.56\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanCollections.Key\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.45\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Ordering\",\"result_type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Ordering.eq\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"default\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"erased\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"any\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},\"uses\":[\"Ordering\",\"PUnit\",\"Prod\",\"LexLeanCollections.Key\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.Key.mk\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setContains\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.containsElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"Bool\",\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.containsElement\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.setInsert\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.insertElement\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}},\"uses\":[\"List\",\"LexLeanCollections.Key\",\"LexLeanCollections.insertElement\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"List.appendTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"List.appendTR\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableList\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.length\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"List.lengthTR\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}},\"uses\":[\"List\",\"Nat\",\"LexLeanRuntime.Lengthable\",\"List.lengthTR\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.multiply\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Mul\",\"instHMul\",\"HMul.hMul\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HMul\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHMul\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HMul\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HMul\",\"Mul\",\"instHMul\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.Key.compare\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanCollections.Key\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.Key.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes._sparseCasesOn_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Ordering\",\"instOfNatNat\",\"Bool.false\",\"Eq.refl\",\"Nat.hasNotBit\",\"Nat.land\",\"Nat.ne_of_beq_eq_false\",\"Nat.shiftRight\",\"OfNat.ofNat\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Ordering.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.compareCodes.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Nat.hasNotBit\",\"Ordering.ctorIdx\",\"Ordering.eq\",\"Unit.unit\",\"LexLeanCollections.compareCodes._sparseCasesOn_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.containsElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"List\",\"Ordering\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"List\",\"Ordering\",\"Unit\",\"LexLeanCollections.Key\",\"List.below\",\"List.cons\",\"List.nil\",\"LexLeanCollections.Key.compare\",\"LexLeanCollections.insertElement.match_1\",\"LexLeanCollections.insertEntry.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertElement.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Ordering\",\"Unit\",\"Ordering.casesOn\",\"Ordering.eq\",\"Ordering.gt\",\"Ordering.lt\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.emptyCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.beq\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.beq\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Chart.mk\",\"parameters\":0,\"fields\":9,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}}}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.match_1\",\"Reasoning.Clinic.Triage.run\",\"Reasoning.Clinic.Triage.Run.state\",\"Reasoning.Clinic.Triage.Run.trace\",\"Reasoning.Clinic.Triage.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":1,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.92\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Vitals.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.feverish\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.temperature\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"380\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.hypotensive\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.systolic\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":4,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.leukocytic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.whiteCells\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"12\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":3,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.recommendationCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Bool.not\",\"Bool.or\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.tachycardic\",\"Reasoning.Clinic.Vitals.infection\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.176\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.84\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.141\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachycardic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.feverish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":5,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.133\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.135\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.137\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.hypotensive\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.154\",\"parameters\":[{\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.142\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.157\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.147\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.157\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.160\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.168\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.170\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.172\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.174\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.183\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.185\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.187\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.189\"}}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.tachycardic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.tachycardic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.heartRate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.tachypneic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.respiratoryRate\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":2,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.GatewayModel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayTriage\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.GatewayTriage\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayTriage\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.GatewayTriage\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.doseLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Screening.Dose.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Dose.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.gatewayLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.GatewayModel\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.GatewayModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.GatewayModel\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.gradeLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Main.Grade.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.93\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.planLeft\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.fst\",\"Reasoning.Main.planLeft.match_1\",\"Reasoning.Planner.Plan.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.screenDose\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Main.Grade.match_1\",\"Reasoning.Screening.Screen.verdict\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.spendLeft\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Reasoning.Budget.Spend.verdict\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Budget.Spend.verdict\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.triageLevel\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Triage.verdict\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.Grade.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.67\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.76\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.verdict\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.95\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.verdict\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.triageSteps\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"OfNat.ofNat\",\"Prod.snd\",\"Reasoning.Clinic.Triage\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Vitals.mk\",\"Reasoning.Main.triageSteps.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}}}}},\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.70\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.92\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Except.error\",\"Except.ok\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Clinic.Triage\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Vitals.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.failure\",\"Reasoning.Planner.Plan.run\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Search.found\",\"Reasoning.Planner.Plan.Search.truncated\",\"Reasoning.Planner.Plan.searchStep.match_5\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":2,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.failure\",\"Reasoning.Planner.Plan.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.measuresCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.29\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.DoseCandidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"30\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"50\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.DoseModel\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.DoseCandidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseCandidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Nat\",\"Reasoning.Screening.DoseCandidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.failure\",\"Reasoning.Screening.Screen.run\",\"Reasoning.Screening.Screen.Node.trace\",\"Reasoning.Screening.Screen.Search.found\",\"Reasoning.Screening.Screen.Search.truncated\",\"Reasoning.Screening.Screen.searchStep.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":1,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.failure\",\"Reasoning.Screening.Screen.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.safeCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"HAdd.hAdd\",\"Nat.ble\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"instAddNat\",\"instHAdd\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.shortCheck\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.ble\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Nat.ble\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.conclusion\",\"Reasoning.Budget.Burn.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.conclusion\",\"Reasoning.Budget.Burn.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.23\"}}}}}}},\"uses\":[\"Nat\",\"Prod\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Burn.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}]}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"parameters\":1,\"fields\":0,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]}}},{\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"Reasoning.Budget.Spend.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.emptyCheck\",\"Reasoning.Budget.Spend.extract\",\"Reasoning.Budget.Spend.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.71\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.emptyCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.80\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.emptyCheck\",\"Reasoning.Budget.Spend.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Budget.Spend.accept\",\"Reasoning.Budget.Spend.extract\",\"Reasoning.Budget.Spend.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.94\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.96\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.98\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Budget.Spend.accept\",\"Reasoning.Budget.Spend.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Option.some\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Reasoning.Budget.Burn.apply\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.apply\",\"Reasoning.Budget.Spend.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Budget.Spend.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.38\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Budget.Spend.Step.Tick\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Budget.Spend.Step.Burn\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}]}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Unit.unit\",\"Reasoning.Budget.Burn.apply\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.apply\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.none\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.fire\",\"Reasoning.Budget.Spend.select\",\"Reasoning.Budget.Spend.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.select\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}]}}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.fire\",\"Reasoning.Budget.Spend.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Prod.snd\",\"Reasoning.Budget.Spend.next\",\"Reasoning.Budget.Spend.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.next\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Budget.Spend.next\",\"Reasoning.Budget.Spend.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.listFold\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Burn.candidates\",\"Reasoning.Budget.Burn.guard\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.guard\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}]}}},\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.111\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"borrow\":false},{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Burn.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.147\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.141\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.Step\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}}}]}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Burn.candidates\",\"Reasoning.Budget.Burn.guard\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Tick.guard\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Budget.Spend.conclude\",\"Reasoning.Budget.Spend.saturate\",\"Reasoning.Budget.Spend.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Spend.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Budget.Spend.conclude\",\"Reasoning.Budget.Spend.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Tick.conclusion\",\"Reasoning.Budget.Tick.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Budget.Tick.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Budget.Tick.conclusion\",\"Reasoning.Budget.Tick.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Tick.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Nat.blt\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.fever\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.leukocytosis\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.level\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.sepsis\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.shock\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.sirs\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.tachycardia\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.tachypnea\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Chart.vitals\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.conclusion\",\"Reasoning.Clinic.Escalate.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.conclusion\",\"Reasoning.Clinic.Escalate.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.16\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Escalate.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Bool.or\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.74\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.219\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.86\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.174\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.121\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.146\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.143\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.145\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.154\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.167\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.161\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.130\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.173\",\"parameters\":[{\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.138\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.156\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.170\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.173\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]}}}]}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.191\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.188\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.191\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.198\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.199\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.197\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.212\",\"parameters\":[{\"id\":\"_uniq.206\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.206\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.175\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.209\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.210\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.215\",\"parameters\":[{\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.212\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.218\",\"parameters\":[{\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.216\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.212\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.215\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.218\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]}}}]}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.219\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.227\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.225\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.229\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.231\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.220\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.233\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.blt\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Fever.conclusion\",\"Reasoning.Clinic.Fever.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Fever.conclusion\",\"Reasoning.Clinic.Fever.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Fever.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.feverish\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.feverish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.feverish\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Leukocytosis.conclusion\",\"Reasoning.Clinic.Leukocytosis.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Leukocytosis.conclusion\",\"Reasoning.Clinic.Leukocytosis.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.leukocytic\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.leukocytic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.leukocytic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sepsis.conclusion\",\"Reasoning.Clinic.Sepsis.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sepsis.conclusion\",\"Reasoning.Clinic.Sepsis.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.vitals\",\"Reasoning.Clinic.Vitals.infection\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Vitals\",\"index\":5,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.65\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.81\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Shock.conclusion\",\"Reasoning.Clinic.Shock.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Shock.conclusion\",\"Reasoning.Clinic.Shock.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Shock.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.hypotensive\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.hypotensive\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.63\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.hypotensive\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sirs.conclusion\",\"Reasoning.Clinic.Sirs.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Sirs.conclusion\",\"Reasoning.Clinic.Sirs.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Sirs.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.and\",\"HAdd.hAdd\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.tachypnea\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}]}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.ble\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachycardia.conclusion\",\"Reasoning.Clinic.Tachycardia.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachycardia.conclusion\",\"Reasoning.Clinic.Tachycardia.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.tachycardic\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachycardic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.tachycardic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachypnea.conclusion\",\"Reasoning.Clinic.Tachypnea.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Tachypnea.conclusion\",\"Reasoning.Clinic.Tachypnea.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.fever\",\"Reasoning.Clinic.Chart.leukocytosis\",\"Reasoning.Clinic.Chart.level\",\"Reasoning.Clinic.Chart.mk\",\"Reasoning.Clinic.Chart.sepsis\",\"Reasoning.Clinic.Chart.shock\",\"Reasoning.Clinic.Chart.sirs\",\"Reasoning.Clinic.Chart.tachycardia\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":1,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":2,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.10\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":4,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":5,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":6,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":7,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.5\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.tachypneic\",\"Reasoning.Clinic.Chart.tachypnea\",\"Reasoning.Clinic.Chart.vitals\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.36\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.tachypneic\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.44\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.tachypneic\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage.Run\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}}}}}]}},{\"name\":\"Reasoning.Clinic.Triage.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]}},{\"name\":\"Reasoning.Clinic.Triage.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.recommendationCheck\",\"Reasoning.Clinic.Triage.extract\",\"Reasoning.Clinic.Triage.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.recommendationCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.57\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.recommendationCheck\",\"Reasoning.Clinic.Triage.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.48\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.245\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.244\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.131\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.141\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.243\",\"parameters\":[{\"id\":\"_uniq.241\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.241\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.242\"}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.142\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.143\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.147\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.239\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.175\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.184\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.238\",\"parameters\":[{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.228\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.229\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.233\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"},{\"kind\":\"fvar\",\"id\":\"_uniq.235\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.237\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.243\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.237\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.185\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.189\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.200\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.226\",\"parameters\":[{\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.216\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.219\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.220\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.175\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.217\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.221\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.222\"},{\"kind\":\"fvar\",\"id\":\"_uniq.223\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.238\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.204\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.205\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.206\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.209\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.191\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.206\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"},{\"kind\":\"fvar\",\"id\":\"_uniq.212\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.207\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.214\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.226\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.227\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.238\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.159\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.164\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.167\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.164\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.165\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.239\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.240\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.243\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.88\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.129\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.123\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.244\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]}}}}}}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.112\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.244\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]}}]}}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.245\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.245\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.accept\",\"Reasoning.Clinic.Triage.extract\",\"Reasoning.Clinic.Triage.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.accept\",\"Reasoning.Clinic.Triage.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}},\"uses\":[\"Nat\",\"Option\",\"Option.some\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Clinic.Triage.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Fever\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Shock\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.none\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}]}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.start\",\"Reasoning.Clinic.Triage.step\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.step\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.start\",\"Reasoning.Clinic.Triage.step\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.next\",\"Reasoning.Clinic.Triage.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.next\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.next\",\"Reasoning.Clinic.Triage.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.273\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.196\",\"parameters\":[{\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.190\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.184\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.197\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.229\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.220\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.222\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.225\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.227\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.272\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.265\",\"parameters\":[{\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.259\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.198\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.260\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.261\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.262\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.263\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.271\",\"parameters\":[{\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.268\",\"parameters\":[{\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.230\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.254\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.268\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.271\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.248\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.251\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.273\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.348\",\"parameters\":[{\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.316\",\"parameters\":[{\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.307\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"},{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.309\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.310\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.311\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.312\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.313\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.314\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.317\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.316\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.334\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.335\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.333\"},{\"kind\":\"fvar\",\"id\":\"_uniq.334\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.347\",\"parameters\":[{\"id\":\"_uniq.341\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.341\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.342\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.343\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.317\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.342\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.343\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.344\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.345\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.344\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.345\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.335\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.336\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.338\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.339\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.340\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.349\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.348\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.362\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.382\",\"parameters\":[{\"id\":\"_uniq.364\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.373\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.374\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.375\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.373\"},{\"kind\":\"fvar\",\"id\":\"_uniq.374\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.375\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.376\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.377\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.377\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.378\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.379\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.380\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.379\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.380\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.382\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.401\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.400\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.437\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.430\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.423\",\"parameters\":[{\"id\":\"_uniq.417\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.417\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.274\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.418\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.420\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.421\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.420\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.421\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.426\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.425\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.349\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.424\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.425\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.429\",\"parameters\":[{\"id\":\"_uniq.427\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.428\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.427\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.428\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.412\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.426\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.429\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.415\"}]}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.436\",\"parameters\":[{\"id\":\"_uniq.434\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.435\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.362\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.434\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.435\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.433\",\"parameters\":[{\"id\":\"_uniq.431\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.432\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.383\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.431\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.432\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.407\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.408\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.433\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.408\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.436\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.401\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.402\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.403\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.403\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.404\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.405\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.406\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.405\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.406\"}]}}}}]}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"List.nil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.observe\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"List.nil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.Ledger\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.observe\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.step\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.attempts\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.Ledger.attempts\",\"Reasoning.Clinic.Triage.Ledger.expansions\",\"Reasoning.Clinic.Triage.Ledger.firings\",\"Reasoning.Clinic.Triage.Ledger.frontier\",\"Reasoning.Clinic.Triage.Ledger.iterations\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Ledger.verifications\",\"Reasoning.Clinic.Triage.Run.ledger\",\"Reasoning.Clinic.Triage.Run.mk\",\"Reasoning.Clinic.Triage.Run.state\",\"Reasoning.Clinic.Triage.Run.trace\",\"Reasoning.Clinic.Triage.next.match_1\",\"Reasoning.Clinic.Triage.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":2,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":0,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":1,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":2,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":3,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":4,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Ledger\",\"index\":5,\"value\":\"_uniq.69\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Triage.Run\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.Run\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}]}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Triage.Ledger\",\"Reasoning.Clinic.Triage.Run\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.attempts\",\"Reasoning.Clinic.Triage.fire\",\"Reasoning.Clinic.Triage.select\",\"Reasoning.Clinic.Triage.Ledger.mk\",\"Reasoning.Clinic.Triage.Run.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.saturate\",\"Reasoning.Clinic.Triage.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Triage.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.56\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Triage.conclude\",\"Reasoning.Clinic.Triage.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.heartRate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.infection\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.respiratoryRate\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.systolic\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.temperature\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Vitals.whiteCells\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Vitals\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]}},{\"name\":\"Reasoning.Main.Grade.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.extract\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"uses\":[\"Nat\",\"Option\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.conclude\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Prod.mk\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.accept\",\"Reasoning.Main.Grade.extract\",\"Reasoning.Main.Grade.conclude.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.52\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.70\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.101\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.accept\",\"Reasoning.Main.Grade.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Chart.level\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Clinic.Chart\",\"index\":8,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Nat\",\"Option\",\"Option.some\",\"Reasoning.Clinic.Chart\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.108\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Main.Grade.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Fever\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.132\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Sirs\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.134\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Sepsis\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Shock\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Main.Grade.Step.Escalate\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.139\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}}}}]}}}}}}}}}}}}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.apply\",\"Reasoning.Clinic.Fever.apply\",\"Reasoning.Clinic.Leukocytosis.apply\",\"Reasoning.Clinic.Sepsis.apply\",\"Reasoning.Clinic.Shock.apply\",\"Reasoning.Clinic.Sirs.apply\",\"Reasoning.Clinic.Tachycardia.apply\",\"Reasoning.Clinic.Tachypnea.apply\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.next\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.none\",\"Reasoning.Clinic.Chart\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire\",\"Reasoning.Main.Grade.select\",\"Reasoning.Main.Grade.next.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.select\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"discriminant\":\"_uniq.48\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}]}}}}}}},\"uses\":[\"Option\",\"PUnit\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.fire\",\"Reasoning.Main.Grade.select\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.7\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"instOfNatNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Clinic.Chart.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.saturate\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.next\",\"Reasoning.Main.Grade.observe\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}]}},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.next\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"11\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.next\",\"Reasoning.Main.Grade.observe\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.select\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.select.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.273\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.197\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Escalate.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.165\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Shock.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.183\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.196\",\"parameters\":[{\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.190\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.191\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.192\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.194\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.184\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.196\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.197\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.229\",\"parameters\":[{\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sepsis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.220\"},{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.222\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.224\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.225\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.226\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.227\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Sirs.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.246\"},{\"kind\":\"fvar\",\"id\":\"_uniq.247\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.272\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.265\",\"parameters\":[{\"id\":\"_uniq.259\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.259\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.198\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.260\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.261\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.262\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.263\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.271\",\"parameters\":[{\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.268\",\"parameters\":[{\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.230\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.267\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.254\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.268\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.271\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.248\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.249\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.251\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.252\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.272\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.273\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.287\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.348\",\"parameters\":[{\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.316\",\"parameters\":[{\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.307\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Leukocytosis.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"},{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.309\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.310\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.311\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.312\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.313\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.314\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.317\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.316\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachypnea.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.334\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.335\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.333\"},{\"kind\":\"fvar\",\"id\":\"_uniq.334\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.347\",\"parameters\":[{\"id\":\"_uniq.341\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.341\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.342\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.343\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.317\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.342\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.343\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.344\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.345\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.296\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.344\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.345\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.335\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.336\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.338\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.339\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.347\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.340\"}]}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.349\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.348\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.362\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.124\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.382\",\"parameters\":[{\"id\":\"_uniq.364\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.373\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Tachycardia.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.374\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.375\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.373\"},{\"kind\":\"fvar\",\"id\":\"_uniq.374\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.375\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.376\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.377\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.377\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.378\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.379\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.380\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.379\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.380\"}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.382\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Fever.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.401\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.400\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.437\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.430\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.423\",\"parameters\":[{\"id\":\"_uniq.417\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.417\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.274\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.418\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.420\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.421\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.420\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.421\"}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.426\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.425\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.349\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.424\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.425\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.429\",\"parameters\":[{\"id\":\"_uniq.427\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.428\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.427\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.423\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.428\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.412\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.426\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.429\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.415\"}]}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.436\",\"parameters\":[{\"id\":\"_uniq.434\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.435\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.362\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.434\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.435\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.433\",\"parameters\":[{\"id\":\"_uniq.431\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.432\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.383\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.431\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.430\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.432\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.407\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.408\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.433\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.408\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.436\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"}]}}]}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"discriminant\":\"_uniq.401\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.402\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.403\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.403\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.404\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.405\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.406\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.405\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.437\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.406\"}]}}}}]}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Escalate.guard\",\"Reasoning.Clinic.Fever.guard\",\"Reasoning.Clinic.Leukocytosis.guard\",\"Reasoning.Clinic.Sepsis.guard\",\"Reasoning.Clinic.Shock.guard\",\"Reasoning.Clinic.Sirs.guard\",\"Reasoning.Clinic.Tachycardia.guard\",\"Reasoning.Clinic.Tachypnea.guard\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Unit\",\"Bool.false\",\"Except.error\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.conclude\",\"Reasoning.Main.Grade.saturate\",\"Reasoning.Main.Grade.account.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Vitals\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.saturate\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.29\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Clinic.Chart\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Main.Grade.conclude\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.50\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Clinic.Chart\",\"Reasoning.Clinic.Vitals\",\"Reasoning.Main.Grade.conclude\",\"Reasoning.Main.Grade.saturate\"]},\"inductive\":null},{\"name\":\"Reasoning.Main.planLeft.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.triageSteps.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.EmptyB.conclusion\",\"Reasoning.Planner.EmptyB.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.EmptyB.conclusion\",\"Reasoning.Planner.EmptyB.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.EmptyB.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.FillA.conclusion\",\"Reasoning.Planner.FillA.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.20\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.FillA.conclusion\",\"Reasoning.Planner.FillA.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.6\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.FillA.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.30\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Node\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Search\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"parameters\":0,\"fields\":5,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}}}}}}]}},{\"name\":\"Reasoning.Planner.Plan.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"parameters\":0,\"fields\":0,\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}}]}},{\"name\":\"Reasoning.Planner.Plan.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.measuresCheck\",\"Reasoning.Planner.Plan.extract\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.measuresCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.measuresCheck\",\"Reasoning.Planner.Plan.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"OfNat.ofNat\",\"Reasoning.Planner.Pour.candidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.9\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}}}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Planner.Pour.candidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Option.some\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.and\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Reasoning.Planner.EmptyB.apply\",\"Reasoning.Planner.FillA.apply\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Pour.apply\",\"Reasoning.Planner.Plan.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.FillA.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.51\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.EmptyB.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.58\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Planner.Plan.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.FillA\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Planner.Plan.Step.Pour\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}}},\"uses\":[\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Unit.unit\",\"Reasoning.Planner.EmptyB.apply\",\"Reasoning.Planner.FillA.apply\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Pour.apply\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fresh\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Node.state\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setContains\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.36\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setContains\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"Reasoning.Planner.Plan.Node\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instMulNat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.multiply\",\"OfNat.ofNat\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.searchStep\",\"Reasoning.Planner.Plan.start\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.searchStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Mul\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instMulNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.multiply\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}}}}},\"uses\":[\"Bool\",\"Mul\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instMulNat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.multiply\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.searchStep\",\"Reasoning.Planner.Plan.start\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.accept\",\"Reasoning.Planner.Plan.attempts\",\"Reasoning.Planner.Plan.fresh\",\"Reasoning.Planner.Plan.successors\",\"Reasoning.Planner.Plan.Ledger.attempts\",\"Reasoning.Planner.Plan.Ledger.expansions\",\"Reasoning.Planner.Plan.Ledger.firings\",\"Reasoning.Planner.Plan.Ledger.frontier\",\"Reasoning.Planner.Plan.Ledger.iterations\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Ledger.verifications\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Search.found\",\"Reasoning.Planner.Plan.Search.frontier\",\"Reasoning.Planner.Plan.Search.ledger\",\"Reasoning.Planner.Plan.Search.mk\",\"Reasoning.Planner.Plan.Search.truncated\",\"Reasoning.Planner.Plan.Search.visited\",\"Reasoning.Planner.Plan.searchStep.match_1\",\"Reasoning.Planner.Plan.searchStep.match_3\",\"Reasoning.Planner.Plan.searchStep.match_5\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.327\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.310\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.139\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":4,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":0,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.150\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":1,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":2,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":3,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":4,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":5,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.294\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fresh\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.179\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.181\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.210\",\"parameters\":[{\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.199\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.198\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.200\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.199\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"},{\"kind\":\"fvar\",\"id\":\"_uniq.200\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.201\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.203\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.205\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.179\"},{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.210\"},{\"kind\":\"fvar\",\"id\":\"_uniq.211\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.212\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.178\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.223\",\"parameters\":[{\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.222\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.223\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.234\",\"parameters\":[{\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.229\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.228\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.229\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.231\"},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.230\"},{\"kind\":\"fvar\",\"id\":\"_uniq.232\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.233\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.234\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.240\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.287\",\"parameters\":[{\"id\":\"_uniq.245\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.247\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":4,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":0,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.251\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.252\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.250\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":1,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.256\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.255\"},{\"kind\":\"fvar\",\"id\":\"_uniq.257\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":2,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.260\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.261\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.260\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.262\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.259\"},{\"kind\":\"fvar\",\"id\":\"_uniq.261\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":3,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.264\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.263\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.265\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":4,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.248\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.265\"},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.275\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Ledger\",\"index\":5,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.260\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.275\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.279\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.277\"},{\"kind\":\"fvar\",\"id\":\"_uniq.278\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.286\",\"parameters\":[{\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.283\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.254\"},{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.262\"},{\"kind\":\"fvar\",\"id\":\"_uniq.264\"},{\"kind\":\"fvar\",\"id\":\"_uniq.266\"},{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.213\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"},{\"kind\":\"fvar\",\"id\":\"_uniq.215\"},{\"kind\":\"fvar\",\"id\":\"_uniq.245\"},{\"kind\":\"fvar\",\"id\":\"_uniq.283\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.285\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.279\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.280\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.275\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.281\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.293\",\"parameters\":[{\"id\":\"_uniq.291\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.224\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.291\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.292\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.290\",\"parameters\":[{\"id\":\"_uniq.288\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.289\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.235\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.288\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.287\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.289\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.240\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.290\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.241\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.293\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.243\"}]}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.295\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.294\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.303\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.303\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.304\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.305\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.306\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.295\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.305\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.306\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.307\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.307\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.308\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.310\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.320\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.320\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.321\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.322\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.321\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.322\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.323\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.324\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.325\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.311\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.323\"},{\"kind\":\"fvar\",\"id\":\"_uniq.324\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.325\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.328\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.327\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.336\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.336\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.337\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.338\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.328\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.337\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.338\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.339\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.340\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.339\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.340\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Planner.Plan.Ledger\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.accept\",\"Reasoning.Planner.Plan.attempts\",\"Reasoning.Planner.Plan.fresh\",\"Reasoning.Planner.Plan.successors\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.observe\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Search.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.Key\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.instKeyProd\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.setInsert\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.65\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.Key\",\"LexLeanCollections.instKeyNat\",\"LexLeanCollections.instKeyProd\",\"LexLeanCollections.listFold\",\"LexLeanCollections.setInsert\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Reasoning.Planner.Plan.Ledger\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Search\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.observe\",\"Reasoning.Planner.Plan.Ledger.mk\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.EmptyB.successors\",\"Reasoning.Planner.Plan.FillA.successors\",\"Reasoning.Planner.Plan.Pour.successors\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.FillA.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.EmptyB.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Pour.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}}}}}}},\"uses\":[\"List\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.EmptyB.successors\",\"Reasoning.Planner.Plan.FillA.successors\",\"Reasoning.Planner.Plan.Pour.successors\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Reasoning.Planner.Plan\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.verdict.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan\",\"Reasoning.Planner.Plan.Step\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.Pour.conclusion\",\"Reasoning.Planner.Pour.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Planner.Pour.conclusion\",\"Reasoning.Planner.Pour.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.subtract\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"Nat\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Pour.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.and\",\"HAdd.hAdd\",\"Nat.ble\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.83\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"4\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.36\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.90\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}}]}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.ble\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Screening.Dose.Trial\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}}}}]}},{\"name\":\"Reasoning.Screening.Dose.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\",\"Reasoning.Screening.Propose.candidates.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.shortCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.84\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.78\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.84\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]}}}]}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.mk\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.Ledger.verifications\",\"Reasoning.Screening.Dose.Trial.ledger\",\"Reasoning.Screening.Dose.Trial.truncated\",\"Reasoning.Screening.Dose.try.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.42\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.93\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.95\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}}}]}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Bool.false\",\"LexLeanCollections.listFold\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.candidates\",\"Reasoning.Screening.Dose.try\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.13\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.try\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.12\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}}}}}}}}},\"uses\":[\"Bool\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"instOfNatNat\",\"Bool.false\",\"LexLeanCollections.listFold\",\"Option.none\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.candidates\",\"Reasoning.Screening.Dose.try\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"HAdd.hAdd\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.verify\",\"Reasoning.Screening.Dose.Ledger.attempts\",\"Reasoning.Screening.Dose.Ledger.expansions\",\"Reasoning.Screening.Dose.Ledger.firings\",\"Reasoning.Screening.Dose.Ledger.frontier\",\"Reasoning.Screening.Dose.Ledger.iterations\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Ledger.verifications\",\"Reasoning.Screening.Dose.Trial.found\",\"Reasoning.Screening.Dose.Trial.ledger\",\"Reasoning.Screening.Dose.Trial.mk\",\"Reasoning.Screening.Dose.Trial.truncated\",\"Reasoning.Screening.Dose.try.match_1\",\"Reasoning.Screening.Dose.try.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.verify\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":1,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":1,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":2,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":3,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":5,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":2,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Ledger\",\"index\":4,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.102\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}]}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"discriminant\":\"_uniq.119\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.121\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Dose.Ledger\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.verify\",\"Reasoning.Screening.Dose.Ledger.mk\",\"Reasoning.Screening.Dose.Trial.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.failure\",\"Reasoning.Screening.Dose.run\",\"Reasoning.Screening.Dose.Trial.found\",\"Reasoning.Screening.Dose.try.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.run\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.Trial\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.38\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.37\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Dose.failure\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Dose.Trial\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Except\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Dose.Trial\",\"Reasoning.Screening.Dose.failure\",\"Reasoning.Screening.Dose.run\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.verify\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.safeCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.apply\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.Propose.conclusion\",\"Reasoning.Screening.Propose.guard\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.guard\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.conclusion\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.Propose.conclusion\",\"Reasoning.Screening.Propose.guard\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.candidates\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.false\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.fst\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\",\"Reasoning.Screening.Propose.candidates.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.DoseModel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.shortCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.85\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.81\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.83\"}}}]}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]}}}]}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.nil\",\"Prod.mk\",\"Reasoning.Screening.DoseModel\",\"Reasoning.Screening.shortCheck\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.conclusion\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"Prod.fst\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.11\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"Nat\",\"Prod\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.guard\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Prod\",\"instOfNatNat\",\"Bool.and\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}}]}}}}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.beq\",\"Nat.blt\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"parameters\":0,\"fields\":6,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]}}}}}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Node\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Search\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"parameters\":0,\"fields\":4,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}}}}}]}},{\"name\":\"Reasoning.Screening.Screen.Step\",\"kind\":\"inductive\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}}]}},{\"name\":\"Reasoning.Screening.Screen.accept\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Reasoning.Screening.safeCheck\",\"Reasoning.Screening.Screen.extract\",\"Reasoning.Screening.Screen.accept.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.safeCheck\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.safeCheck\",\"Reasoning.Screening.Screen.extract\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Screening.Propose.candidates\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"Reasoning.Screening.Propose.candidates\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.extract\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.snd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Nat.blt\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.failure\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.and\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.44\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.49\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.48\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.69\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}]}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.69\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.72\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.75\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]}}}]}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.fire\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Reasoning.Screening.Propose.apply\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.31\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.apply\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.31\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Reasoning.Screening.Screen.Step\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.24\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Reasoning.Screening.Screen.Step.Propose\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}}]}}}},\"uses\":[\"Nat\",\"Option\",\"Prod\",\"Reasoning.Screening.Propose.apply\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.observe\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"OfNat.ofNat\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"Nat\",\"OfNat\",\"Prod\",\"instOfNatNat\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.run\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"OfNat.ofNat\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.searchStep\",\"Reasoning.Screening.Screen.start\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.searchStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.13\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.start\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}}}}},\"uses\":[\"Bool\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.searchStep\",\"Reasoning.Screening.Screen.start\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.or\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.accept\",\"Reasoning.Screening.Screen.attempts\",\"Reasoning.Screening.Screen.successors\",\"Reasoning.Screening.Dose.try.match_3\",\"Reasoning.Screening.Screen.Ledger.attempts\",\"Reasoning.Screening.Screen.Ledger.expansions\",\"Reasoning.Screening.Screen.Ledger.firings\",\"Reasoning.Screening.Screen.Ledger.frontier\",\"Reasoning.Screening.Screen.Ledger.iterations\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Ledger.verifications\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Search.found\",\"Reasoning.Screening.Screen.Search.frontier\",\"Reasoning.Screening.Screen.Search.ledger\",\"Reasoning.Screening.Screen.Search.mk\",\"Reasoning.Screening.Screen.Search.truncated\",\"Reasoning.Screening.Screen.searchStep.match_1\",\"Reasoning.Screening.Screen.searchStep.match_3\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.320\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.115\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.114\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.303\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.138\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":0,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.149\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":1,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":2,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":3,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":4,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"},{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":5,\"value\":\"_uniq.140\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.152\"},{\"kind\":\"fvar\",\"id\":\"_uniq.153\"},{\"kind\":\"fvar\",\"id\":\"_uniq.154\"},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"},{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.160\"}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.287\",\"parameters\":[{\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.173\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.174\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.177\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.205\",\"parameters\":[{\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.192\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.191\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.193\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.195\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.194\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.196\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.192\"},{\"kind\":\"fvar\",\"id\":\"_uniq.195\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.197\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.198\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.196\"},{\"kind\":\"fvar\",\"id\":\"_uniq.197\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.198\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.199\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.181\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.200\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.182\"},{\"kind\":\"fvar\",\"id\":\"_uniq.201\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.176\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"},{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.205\"},{\"kind\":\"fvar\",\"id\":\"_uniq.206\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.207\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.217\",\"parameters\":[{\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.216\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.217\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.227\",\"parameters\":[{\"id\":\"_uniq.220\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.222\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.223\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.222\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"},{\"kind\":\"fvar\",\"id\":\"_uniq.178\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.226\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.223\"},{\"kind\":\"fvar\",\"id\":\"_uniq.225\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.226\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.228\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.227\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":2,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.280\",\"parameters\":[{\"id\":\"_uniq.238\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.239\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.240\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.239\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.241\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.240\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":3,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.243\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":0,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.247\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.243\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":1,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.attempts\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.249\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.251\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.248\"},{\"kind\":\"fvar\",\"id\":\"_uniq.250\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.252\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":2,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.253\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.254\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.255\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.252\"},{\"kind\":\"fvar\",\"id\":\"_uniq.254\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.256\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":3,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.257\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.256\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.258\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":4,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.259\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.241\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.258\"},{\"kind\":\"fvar\",\"id\":\"_uniq.246\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Ledger\",\"index\":5,\"value\":\"_uniq.242\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.253\"},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.268\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"},{\"kind\":\"fvar\",\"id\":\"_uniq.271\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.279\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.276\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.247\"},{\"kind\":\"fvar\",\"id\":\"_uniq.251\"},{\"kind\":\"fvar\",\"id\":\"_uniq.255\"},{\"kind\":\"fvar\",\"id\":\"_uniq.257\"},{\"kind\":\"fvar\",\"id\":\"_uniq.259\"},{\"kind\":\"fvar\",\"id\":\"_uniq.275\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.277\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.208\"},{\"kind\":\"fvar\",\"id\":\"_uniq.209\"},{\"kind\":\"fvar\",\"id\":\"_uniq.238\"},{\"kind\":\"fvar\",\"id\":\"_uniq.276\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.278\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.277\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.278\"}}}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.272\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.273\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.279\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.268\"}]}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.274\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.279\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.269\"}]}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.286\",\"parameters\":[{\"id\":\"_uniq.284\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.285\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.218\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.284\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.280\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.285\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.283\",\"parameters\":[{\"id\":\"_uniq.281\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.282\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.228\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.281\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.280\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.282\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.233\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.283\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.234\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.286\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.236\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.288\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.287\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.126\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.297\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.accept\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.296\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.297\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.299\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.288\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.298\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.299\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.300\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.301\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.300\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.301\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.304\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.303\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.313\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.315\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.314\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.315\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.316\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.317\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.318\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.304\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.316\"},{\"kind\":\"fvar\",\"id\":\"_uniq.317\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.318\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.321\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.320\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.329\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Search\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"discriminant\":\"_uniq.329\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.330\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.331\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.321\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.330\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.331\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.332\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.333\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.332\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.333\"}}}]}}}}}}},\"uses\":[\"Add\",\"Bool\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"Reasoning.Screening.Screen.Ledger\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.accept\",\"Reasoning.Screening.Screen.attempts\",\"Reasoning.Screening.Screen.successors\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.start\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.observe\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Search.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.34\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.17\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.observe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.59\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"LexLeanRuntime.instLengthableList\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Option.none\",\"Reasoning.Screening.Screen.Ledger\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Search\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.observe\",\"Reasoning.Screening.Screen.Ledger.mk\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Search.mk\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.successors\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Propose.successors\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"List\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.successors\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.verdict\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Prod.fst\",\"Reasoning.Screening.Screen\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.verdict.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.53\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}},\"uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen\",\"Reasoning.Screening.Screen.Step\"]},\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.Burn\",\"kind\":\"constructor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.Tick\",\"kind\":\"constructor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\",\"Reasoning.Budget.Spend.Step.Burn\",\"Reasoning.Budget.Spend.Step.Tick\",\"Reasoning.Budget.Spend.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Budget.Spend.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Budget\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Budget.Spend.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Run.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Run\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Escalate\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Fever\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Sepsis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Shock\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Sirs\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"kind\":\"constructor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\",\"Reasoning.Clinic.Triage.Step.Escalate\",\"Reasoning.Clinic.Triage.Step.Fever\",\"Reasoning.Clinic.Triage.Step.Leukocytosis\",\"Reasoning.Clinic.Triage.Step.Sepsis\",\"Reasoning.Clinic.Triage.Step.Shock\",\"Reasoning.Clinic.Triage.Step.Sirs\",\"Reasoning.Clinic.Triage.Step.Tachycardia\",\"Reasoning.Clinic.Triage.Step.Tachypnea\",\"Reasoning.Clinic.Triage.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Chart\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Clinic.Triage.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Clinic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Clinic.Triage.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Escalate\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Fever\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Leukocytosis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Sepsis\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Shock\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Sirs\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Tachycardia\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.Tachypnea\",\"kind\":\"constructor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.account.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.conclude.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Unit\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\",\"Reasoning.Main.Grade.Step.Escalate\",\"Reasoning.Main.Grade.Step.Fever\",\"Reasoning.Main.Grade.Step.Leukocytosis\",\"Reasoning.Main.Grade.Step.Sepsis\",\"Reasoning.Main.Grade.Step.Shock\",\"Reasoning.Main.Grade.Step.Sirs\",\"Reasoning.Main.Grade.Step.Tachycardia\",\"Reasoning.Main.Grade.Step.Tachypnea\",\"Reasoning.Main.Grade.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.next.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Main.Grade.select.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Main\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Main.Grade.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.EmptyB.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.EmptyB\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.FillA.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.FillA\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Node.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Pour.collect\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Node.trace\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.fire\",\"Reasoning.Planner.Plan.Node.mk\",\"Reasoning.Planner.Plan.Step.Pour\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Pour.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Pour.candidates\",\"Reasoning.Planner.Plan.Node.state\",\"Reasoning.Planner.Plan.Pour.collect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Pour.collect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Planner.Plan.Node\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Pour.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Planner.Plan.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Planner.Plan.Node\",\"Reasoning.Planner.Pour.candidates\",\"Reasoning.Planner.Plan.Pour.collect\"]},\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Search.visited\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Planner.Plan.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.EmptyB\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.FillA\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.Pour\",\"kind\":\"constructor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Unit\",\"Unit.unit\",\"Reasoning.Planner.Plan.Step\",\"Reasoning.Planner.Plan.Step.EmptyB\",\"Reasoning.Planner.Plan.Step.FillA\",\"Reasoning.Planner.Plan.Step.Pour\",\"Reasoning.Planner.Plan.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.searchStep.match_5\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Planner.Plan.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Planner.Plan.verdict.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Planner\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Planner.Plan.Step\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.Trial.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Dose.Trial\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Unit\",\"Bool.casesOn\",\"Bool.false\",\"Bool.true\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Dose.try.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Propose.candidates.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.attempts\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.expansions\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.firings\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.iterations\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Ledger.verifications\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Ledger\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.state\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Node.trace\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Propose.collect\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Node.trace\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.replay.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.43\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableList\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":1,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.fire\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}]}}}}}}}}},\"uses\":[\"List\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableList\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.fire\",\"Reasoning.Screening.Screen.Node.mk\",\"Reasoning.Screening.Screen.Step.Propose\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Propose.successors\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Screening.Propose.candidates\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Node.state\",\"Reasoning.Screening.Screen.Propose.collect\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Propose.collect\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Reasoning.Screening.Screen.Node\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Propose.candidates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Reasoning.Screening.Screen.Node\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.18\"}}}}}}},\"uses\":[\"List\",\"Nat\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"Reasoning.Screening.Propose.candidates\",\"Reasoning.Screening.Screen.Node\",\"Reasoning.Screening.Screen.Propose.collect\"]},\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.found\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.frontier\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.ledger\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.mk\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Search.truncated\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Reasoning.Screening.Screen.Search\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.Propose\",\"kind\":\"constructor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.casesOn\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.Step.rec\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.Step.rec\",\"kind\":\"recursor\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.accept.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.fire.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Reasoning.Screening.Screen.Step\",\"Reasoning.Screening.Screen.Step.Propose\",\"Reasoning.Screening.Screen.Step.casesOn\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.replay.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.searchStep.match_3\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"Reasoning.Screening.Screen.Node\"],\"declaration\":null,\"inductive\":null},{\"name\":\"Reasoning.Screening.Screen.verdict.match_1\",\"kind\":\"definition\",\"module\":\"Reasoning.Screening\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Except\",\"List\",\"Nat\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"Reasoning.Screening.Screen.Step\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HMul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Mul\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHMul\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instMulNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOrdNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"List.appendTR\",\"kind\":\"definition\",\"module\":\"Init.Data.List.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.lengthTR\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Ordering.eq\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.gt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Ordering.lt\",\"kind\":\"constructor\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Ordering\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"d2c9b0ff12d25eb940a8ff94fdbfcd8794392d439e10d7eaa35eefbe43ed2b4b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0.lean index b40893d86..7c5a7b962 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat, .nat, .nat, .nat, .nat]] }, @@ -388,4 +388,4 @@ def denote (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteC theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] (_root_.LexLeanPreservation.Rel (__fits_0 temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.triageLevel temperature heartRate respiratoryRate whiteCells systolic infection))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 temperature heartRate respiratoryRate whiteCells systolic infection) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/Compose/RustCore.lex.tex similarity index 96% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/Compose/RustCore.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/Compose/RustCore.lex.tex index 59590d8d1..a9b995a93 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/Compose/RustCore.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/Compose/RustCore.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_0 : @16 := @716 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_1 : @724 := @1388 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_2 : @1396 := @1631 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.root : @2716 := @2717 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.flags @3 := Reasoning.Clinic.Vitals @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -381,7 +381,7 @@ @715 := @13 (@680 @108) @10 @716 := fun (__s : @3) => @712 @717 := Reasoning.Clinic.Chart -@719 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.__enc_1 @4 +@719 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.__enc_1 @4 @720 := 1 @721 := @8 @720 @724 := (__s : @717) -> @13 @719 @721 @@ -404,7 +404,7 @@ @741 := Reasoning.Clinic.Chart.level @742 := @741 @4 @743 := @5 @726 -@745 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_0 @726 +@745 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_0 @726 @746 := @29 @728 @747 := @64 @728 @749 := @13 @746 @31 @@ -688,7 +688,7 @@ @1387 := @13 (@680 @795) @721 @1388 := fun (__s : @717) => @1384 @1389 := Reasoning.Clinic.Triage.Step -@1391 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.__enc_2 @4 +@1391 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.__enc_2 @4 @1392 := 2 @1393 := @8 @1392 @1395 := @13 @1391 @1393 @@ -867,7 +867,7 @@ @1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 @1719 := List.getD.{0} @1701 @1703 @9 @1714 @1723 := fun (__e_n : @35) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.root @4 @9 @1724 := @221 @1652 @1725 := @1642 @38 @1727 := @143 (@1666 @36) @@ -1005,12 +1005,12 @@ @1968 := @1963 @1925 @1969 := @143 @1667 @1970 := @1969 @117 -@1971 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.denote +@1971 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.denote @1977 := @1971 @149 @151 @153 @36 @38 @40 -@1978 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.__fits_0 +@1978 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.__fits_0 @1984 := @1978 @149 @151 @153 @36 @38 @40 @1992 := @29 (Reasoning.Main.triageLevel @149 @151 @153 @36 @38 @40) -@1999 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.root @149 @151 @153 @36 @38 @40 +@1999 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.root @149 @151 @153 @36 @38 @40 @2000 := Bool @2001 := Ne.{1} @2002 := LexLeanPreservation.Obs diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/RustCore.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/RustCore.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/RustCore.lean index 3cdfe7f7d..8d2a04607 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/RustCore.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -357,4 +357,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1.lean index 06cde9558..e1cdbdf9b 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat, .nat, .nat, .nat, .nat]] }, @@ -406,4 +406,4 @@ def denote (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteC theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] (_root_.LexLeanPreservation.Rel (__fits_0 temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.gatewayLevel temperature heartRate respiratoryRate whiteCells systolic infection))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 temperature heartRate respiratoryRate whiteCells systolic infection) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/Compose/RustCore.lex.tex similarity index 96% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/Compose/RustCore.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/Compose/RustCore.lex.tex index bfe87fb4a..be58dc7d3 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/Compose/RustCore.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/Compose/RustCore.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_0 : @16 := @716 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_1 : @724 := @1388 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_2 : @1396 := @1631 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.root : @2716 := @2717 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.flags @3 := Reasoning.Clinic.Vitals @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -381,7 +381,7 @@ @715 := @13 (@680 @108) @10 @716 := fun (__s : @3) => @712 @717 := Reasoning.Clinic.Chart -@719 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.__enc_1 @4 +@719 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.__enc_1 @4 @720 := 1 @721 := @8 @720 @724 := (__s : @717) -> @13 @719 @721 @@ -404,7 +404,7 @@ @741 := Reasoning.Clinic.Chart.level @742 := @741 @4 @743 := @5 @726 -@745 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_0 @726 +@745 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_0 @726 @746 := @29 @728 @747 := @64 @728 @749 := @13 @746 @31 @@ -688,7 +688,7 @@ @1387 := @13 (@680 @795) @721 @1388 := fun (__s : @717) => @1384 @1389 := Reasoning.Clinic.Triage.Step -@1391 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.__enc_2 @4 +@1391 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.__enc_2 @4 @1392 := 2 @1393 := @8 @1392 @1395 := @13 @1391 @1393 @@ -867,7 +867,7 @@ @1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 @1719 := List.getD.{0} @1701 @1703 @9 @1714 @1723 := fun (__e_n : @35) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.root @4 @9 @1724 := @221 @1652 @1725 := @1642 @38 @1727 := @143 (@1666 @36) @@ -1005,12 +1005,12 @@ @1968 := @1963 @1925 @1969 := @143 @1667 @1970 := @1969 @117 -@1971 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.denote +@1971 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.denote @1977 := @1971 @149 @151 @153 @36 @38 @40 -@1978 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.__fits_0 +@1978 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.__fits_0 @1984 := @1978 @149 @151 @153 @36 @38 @40 @1992 := @29 (Reasoning.Main.gatewayLevel @149 @151 @153 @36 @38 @40) -@1999 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.root @149 @151 @153 @36 @38 @40 +@1999 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.root @149 @151 @153 @36 @38 @40 @2000 := Bool @2001 := Ne.{1} @2002 := LexLeanPreservation.Obs diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/RustCore.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/RustCore.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/RustCore.lean index 247bf8a8e..962eba60f 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/RustCore.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -373,4 +373,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2.lean index 8c1ee9d72..1d6c54953 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat, .nat, .nat, .nat, .nat]] }, @@ -414,4 +414,4 @@ def denote (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteC theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] (_root_.LexLeanPreservation.Rel (__fits_0 temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.triageSteps temperature heartRate respiratoryRate whiteCells systolic infection))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 temperature heartRate respiratoryRate whiteCells systolic infection) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/Compose/RustStd.lex.tex similarity index 96% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/Compose/RustStd.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/Compose/RustStd.lex.tex index 85152e328..e1ca87eb6 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/Compose/RustStd.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/Compose/RustStd.lex.tex @@ -1,61 +1,61 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_0 : @16 := @716 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_1 : @724 := @960 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_1 : @724 := @960 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_3 : @967 := @1631 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_3], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_3 : @967 := @1631 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_3], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_4 : @1638 := @2091 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_4], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_4 : @1638 := @2091 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_4], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_2 : @2098 := @2458 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_2 : @2098 := @2458 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.root : @3543 := @3544 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.root : @3543 := @3544 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.flags @3 := Reasoning.Clinic.Vitals @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -399,7 +399,7 @@ @715 := @13 (@680 @108) @10 @716 := fun (__s : @3) => @712 @717 := Reasoning.Clinic.Triage.Step -@718 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__enc_1 +@718 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__enc_1 @719 := @718 @4 @720 := 1 @721 := @8 @720 @@ -516,7 +516,7 @@ @960 := fun (__v : @717) => Reasoning.Clinic.Triage.Step.casesOn.{0} @725 @4 @760 @786 @813 @840 @867 @894 @921 @948 @961 := Reasoning.Clinic.Chart -@962 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__enc_3 +@962 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__enc_3 @963 := @962 @4 @964 := @8 @814 @967 := (__s : @961) -> @13 @963 @964 @@ -539,7 +539,7 @@ @984 := Reasoning.Clinic.Chart.level @985 := @984 @4 @986 := @5 @969 -@988 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_0 @969 +@988 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_0 @969 @989 := @29 @971 @990 := @64 @971 @992 := @13 @989 @31 @@ -823,7 +823,7 @@ @1630 := @13 (@680 @1038) @964 @1631 := fun (__s : @961) => @1627 @1632 := Reasoning.Clinic.Triage.Ledger -@1633 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__enc_4 +@1633 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__enc_4 @1634 := @1633 @4 @1635 := @8 @841 @1638 := (__s : @1632) -> @13 @1634 @1635 @@ -1031,7 +1031,7 @@ @2090 := @13 (@680 @1686) @1635 @2091 := fun (__s : @1632) => @2087 @2092 := Reasoning.Clinic.Triage.Run -@2094 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__enc_2 @4 +@2094 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__enc_2 @4 @2095 := @8 @787 @2098 := (__s : @2092) -> @13 @2094 @2095 @2099 := Reasoning.Clinic.Triage.Run.state @@ -1041,7 +1041,7 @@ @2103 := Reasoning.Clinic.Triage.Run.ledger @2104 := @2103 @4 @2105 := @962 @2100 -@2107 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_3 @2100 +@2107 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_3 @2100 @2108 := LexLeanPreservation.encList @2109 := @2108 @717 @2110 := @2109 @718 @@ -1049,7 +1049,7 @@ @2112 := LexLeanTarget.TargetSyntax.Ty.list @2113 := @2112 @721 @2116 := fun (__x : @717) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_1 @4 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_1 @4 @2117 := Sort 1 @2118 := (a._@._internal._hyg.#0 : @4) -> @91 @2119 := @38 @4 @@ -1091,7 +1091,7 @@ @2208 := @2202 @2116 @2102 @2210 := @13 @2111 @2113 @2211 := @1633 @2104 -@2213 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_4 @2104 +@2213 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_4 @2104 @2215 := @96 @2211 @95 @2217 := @96 @2111 @2215 @2219 := @96 @2105 @2217 @@ -1267,7 +1267,7 @@ @2541 := LexLeanTarget.TargetSyntax.Function.mk @2531 @109 @2532 @2536 @2546 := List.getD.{0} @2528 @2530 @9 @2541 @2550 := fun (__e_n : @35) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.root @4 @9 @2551 := @221 @2479 @2552 := @2469 @38 @2554 := @143 (@2493 @36) @@ -1405,12 +1405,12 @@ @2795 := @2790 @2752 @2796 := @143 @2494 @2797 := @2796 @117 -@2798 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.denote +@2798 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.denote @2804 := @2798 @149 @151 @153 @36 @38 @40 -@2805 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.__fits_0 +@2805 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.__fits_0 @2811 := @2805 @149 @151 @153 @36 @38 @40 @2819 := @29 (Reasoning.Main.triageSteps @149 @151 @153 @36 @38 @40) -@2826 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.root @149 @151 @153 @36 @38 @40 +@2826 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.root @149 @151 @153 @36 @38 @40 @2827 := Bool @2828 := Ne.{1} @2829 := LexLeanPreservation.Obs diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/RustStd.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/RustStd.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/RustStd.lean index ebd704e77..f26edfc56 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/RustStd.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -377,4 +377,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3.lean index 6851322ae..080bec382 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [], [.nat]] }, @@ -346,4 +346,4 @@ def denote (target : Nat) : _root_.LexLeanPreservation.Obs := theorem root (target : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat target)] (_root_.LexLeanPreservation.Rel (__fits_0 target) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.planLeft target))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 target) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/Compose/RustStd.lex.tex similarity index 95% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/Compose/RustStd.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/Compose/RustStd.lex.tex index 98693afb1..e78e6478b 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/Compose/RustStd.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/Compose/RustStd.lex.tex @@ -1,54 +1,54 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_0 : @16 := @424 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_0 : @16 := @424 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_2 : @431 := @905 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_2 : @431 := @905 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_3 : @913 := @1372 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_3], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_3 : @913 := @1372 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_3], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_1 : @1379 := @2024 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_1 : @1379 := @2024 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.root : @2637 := @2638 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.root : @2637 := @2638 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.flags @3 := Reasoning.Planner.Plan.Step @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -265,7 +265,7 @@ @417 := fun (__x0 : @57) => @413 @424 := fun (__v : @3) => Reasoning.Planner.Plan.Step.casesOn.{0} @17 @4 @191 @218 @417 @425 := Reasoning.Planner.Plan.Node -@426 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.__enc_2 +@426 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.__enc_2 @427 := @426 @4 @428 := @8 @378 @429 := @13 @427 @@ -372,7 +372,7 @@ @632 := LexLeanTarget.TargetSyntax.Ty.list @633 := @632 @10 @636 := fun (__x : @3) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_0 @4 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_0 @4 @637 := (a._@._internal._hyg.#0 : @4) -> @18 @638 := @28 @4 @641 := (x : @28) -> @259 @638 @30 @@ -489,7 +489,7 @@ @904 := @13 (@166 @733) @428 @905 := fun (__s : @425) => @901 @906 := Reasoning.Planner.Plan.Ledger -@907 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.__enc_3 +@907 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.__enc_3 @908 := @907 @4 @909 := 3 @910 := @8 @909 @@ -703,7 +703,7 @@ @1371 := @13 (@166 @961) @910 @1372 := fun (__s : @906) => @1368 @1373 := Reasoning.Planner.Plan.Search -@1375 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.__enc_1 @4 +@1375 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.__enc_1 @4 @1376 := @8 @192 @1379 := (__s : @1373) -> @13 @1375 @1376 @1380 := Reasoning.Planner.Plan.Search.frontier @@ -721,7 +721,7 @@ @1392 := @1391 @1381 @1393 := @632 @428 @1396 := fun (__x : @425) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_2 @4 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_2 @4 @1397 := @689 @425 @1398 := (a._@._internal._hyg.#0 : @425) -> @18 @1399 := (x : @425) -> @691 @@ -839,7 +839,7 @@ @1646 := @1642 @1387 @1648 := @13 @1620 @1621 @1649 := @907 @1389 -@1651 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_3 @1389 +@1651 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_3 @1389 @1653 := @251 @1649 @22 @1655 := @251 @1620 @1653 @1657 := @251 @1471 @1655 @@ -1026,7 +1026,7 @@ @2050 := LexLeanTarget.TargetSyntax.Function.mk @2040 @23 @2041 @2045 @2055 := List.getD.{0} @2037 @2039 @9 @2050 @2059 := fun (__e_n : @57) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.root @4 @9 @2060 := @312 @352 @2062 := @13 @341 @28 @2063 := @219 @66 @@ -1041,12 +1041,12 @@ @2087 := @2080 @23 @2090 := (h : @354) -> (hs : @56) -> @357 @256 @2092 := @2087 @2025 @53 -@2093 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.denote +@2093 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.denote @2094 := @2093 @30 -@2095 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.__fits_0 +@2095 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.__fits_0 @2096 := @2095 @30 @2099 := @219 (Reasoning.Main.planLeft @30) -@2101 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.root @30 +@2101 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.root @30 @2102 := Ne.{1} @2103 := LexLeanPreservation.Obs @2104 := @2102 @2103 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/RustStd.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/RustStd.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/RustStd.lean index 00e5fbb08..f0210c10c 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/RustStd.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -357,4 +357,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4.lean index 46fae9ac5..cd5982709 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[(.option .nat), .bool, (.adt 1)]] }, @@ -139,4 +139,4 @@ def denote (w : Nat) : _root_.LexLeanPreservation.Obs := theorem root (w : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)] (_root_.LexLeanPreservation.Rel (__fits_0 w) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.doseLevel w))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 w) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/Compose/RustStd.lex.tex similarity index 95% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/Compose/RustStd.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/Compose/RustStd.lex.tex index f617b75e0..458cbb9a2 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/Compose/RustStd.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/Compose/RustStd.lex.tex @@ -1,40 +1,40 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_1 : @16 := @717 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_1 : @16 := @717 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_0 : @724 := @1108 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_0 : @724 := @1108 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.root : @1754 := @1755 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.root : @1754 := @1755 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.flags @3 := Reasoning.Screening.Dose.Ledger @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.__enc_1 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.__enc_1 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -382,7 +382,7 @@ @716 := @13 (@681 @108) @10 @717 := fun (__s : @3) => @713 @718 := Reasoning.Screening.Dose.Trial -@720 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.__enc_0 @4 +@720 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.__enc_0 @4 @721 := @8 @595 @724 := (__s : @718) -> @13 @720 @721 @725 := Reasoning.Screening.Dose.Trial.found @@ -452,7 +452,7 @@ @860 := @856 @728 @862 := @13 @834 @835 @863 := @5 @730 -@865 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_1 @730 +@865 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_1 @730 @867 := @96 @863 @95 @869 := @96 @834 @867 @871 := @96 @734 @869 @@ -582,7 +582,7 @@ @1141 := LexLeanTarget.TargetSyntax.Function.mk @1131 @109 @1132 @1136 @1146 := List.getD.{0} @1128 @1130 @595 @1141 @1150 := fun (__e_n : @35) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.root @4 @595 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.root @4 @595 @1151 := @221 @1109 @1152 := @29 @153 @1154 := @13 @1152 @38 @@ -613,12 +613,12 @@ @1202 := @1196 @142 @1203 := @143 @1114 @1204 := @1203 @112 -@1205 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.denote +@1205 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.denote @1206 := @1205 @40 -@1207 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.__fits_0 +@1207 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.__fits_0 @1208 := @1207 @40 @1211 := @29 (Reasoning.Main.doseLevel @40) -@1213 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.root @40 +@1213 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.root @40 @1214 := Ne.{1} @1215 := LexLeanPreservation.Obs @1216 := @1214 @1215 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/RustStd.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/RustStd.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/RustStd.lean index 793930d38..501874cb4 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/RustStd.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -131,4 +131,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5.lean index 2ad2572b4..ab3b11e5c 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat, .nat, .nat, .nat, .nat, .nat]] }, @@ -379,4 +379,4 @@ def denote (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteC theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] (_root_.LexLeanPreservation.Rel (__fits_0 temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.gradeLevel temperature heartRate respiratoryRate whiteCells systolic infection))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 temperature heartRate respiratoryRate whiteCells systolic infection) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/Compose/RustCore.lex.tex similarity index 96% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/Compose/RustCore.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/Compose/RustCore.lex.tex index 75835e2dc..1ef1e32fd 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/Compose/RustCore.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/Compose/RustCore.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustCore} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_0 : @16 := @716 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_1 : @724 := @1388 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_2 : @1396 := @1631 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.root : @2716 := @2717 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.flags @3 := Reasoning.Clinic.Vitals @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -381,7 +381,7 @@ @715 := @13 (@680 @108) @10 @716 := fun (__s : @3) => @712 @717 := Reasoning.Clinic.Chart -@719 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.__enc_1 @4 +@719 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.__enc_1 @4 @720 := 1 @721 := @8 @720 @724 := (__s : @717) -> @13 @719 @721 @@ -404,7 +404,7 @@ @741 := Reasoning.Clinic.Chart.level @742 := @741 @4 @743 := @5 @726 -@745 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_0 @726 +@745 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_0 @726 @746 := @29 @728 @747 := @64 @728 @749 := @13 @746 @31 @@ -688,7 +688,7 @@ @1387 := @13 (@680 @795) @721 @1388 := fun (__s : @717) => @1384 @1389 := Reasoning.Main.Grade.Step -@1391 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.__enc_2 @4 +@1391 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.__enc_2 @4 @1392 := 2 @1393 := @8 @1392 @1395 := @13 @1391 @1393 @@ -867,7 +867,7 @@ @1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 @1719 := List.getD.{0} @1701 @1703 @9 @1714 @1723 := fun (__e_n : @35) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.root @4 @9 @1724 := @221 @1652 @1725 := @1642 @38 @1727 := @143 (@1666 @36) @@ -1005,12 +1005,12 @@ @1968 := @1963 @1925 @1969 := @143 @1667 @1970 := @1969 @117 -@1971 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.denote +@1971 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.denote @1977 := @1971 @149 @151 @153 @36 @38 @40 -@1978 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.__fits_0 +@1978 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.__fits_0 @1984 := @1978 @149 @151 @153 @36 @38 @40 @1992 := @29 (Reasoning.Main.gradeLevel @149 @151 @153 @36 @38 @40) -@1999 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.root @149 @151 @153 @36 @38 @40 +@1999 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.root @149 @151 @153 @36 @38 @40 @2000 := Bool @2001 := Ne.{1} @2002 := LexLeanPreservation.Obs diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/RustCore.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/RustCore.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/RustCore.lean index c9d747778..d8f931617 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/RustCore.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/RustCore.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -349,4 +349,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6.lean index 412fa9f75..8bd67f958 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.nat]] }, @@ -280,4 +280,4 @@ def denote (w : Nat) : _root_.LexLeanPreservation.Obs := theorem root (w : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)] (_root_.LexLeanPreservation.Rel (__fits_0 w) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.screenDose w))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 w) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/Compose/RustStd.lex.tex similarity index 95% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/Compose/RustStd.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/Compose/RustStd.lex.tex index b53dbc238..5165ff664 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/Compose/RustStd.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/Compose/RustStd.lex.tex @@ -1,54 +1,54 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_0 : @16 := @367 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_0 : @16 := @367 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_2 : @375 := @849 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_2], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_2 : @375 := @849 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_3 : @857 := @1316 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_3], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_3 : @857 := @1316 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_3], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_1 : @1324 := @1844 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_1 : @1324 := @1844 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.root : @2457 := @2458 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.root : @2457 := @2458 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.flags @3 := Reasoning.Screening.Screen.Step @4 := #0 -@5 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.__enc_0 +@5 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -242,7 +242,7 @@ @362 := fun (__x0 : @24) => @358 @367 := fun (__v : @3) => Reasoning.Screening.Screen.Step.casesOn.{0} @17 @4 @362 @368 := Reasoning.Screening.Screen.Node -@369 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.__enc_2 +@369 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.__enc_2 @370 := @369 @4 @371 := 2 @372 := @8 @371 @@ -349,7 +349,7 @@ @576 := LexLeanTarget.TargetSyntax.Ty.list @577 := @576 @10 @580 := fun (__x : @3) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_0 @4 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_0 @4 @581 := (a._@._internal._hyg.#0 : @4) -> @57 @582 := @27 @4 @585 := (x : @27) -> @105 @582 @29 @@ -466,7 +466,7 @@ @848 := @13 (@326 @677) @372 @849 := fun (__s : @368) => @845 @850 := Reasoning.Screening.Screen.Ledger -@851 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.__enc_3 +@851 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.__enc_3 @852 := @851 @4 @853 := 3 @854 := @8 @853 @@ -680,7 +680,7 @@ @1315 := @13 (@326 @905) @854 @1316 := fun (__s : @850) => @1312 @1317 := Reasoning.Screening.Screen.Search -@1319 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.__enc_1 @4 +@1319 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.__enc_1 @4 @1320 := 1 @1321 := @8 @1320 @1324 := (__s : @1317) -> @13 @1319 @1321 @@ -697,7 +697,7 @@ @1335 := @1334 @1326 @1336 := @576 @372 @1339 := fun (__x : @368) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_2 @4 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_2 @4 @1340 := @633 @368 @1341 := (a._@._internal._hyg.#0 : @368) -> @57 @1342 := (x : @368) -> @635 @@ -786,7 +786,7 @@ @1531 := @1527 @1330 @1533 := @13 @1505 @1506 @1534 := @851 @1332 -@1536 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_3 @1332 +@1536 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_3 @1332 @1538 := @62 @1534 @61 @1540 := @62 @1505 @1538 @1542 := @62 @1377 @1540 @@ -943,7 +943,7 @@ @1870 := LexLeanTarget.TargetSyntax.Function.mk @1860 @65 @1861 @1865 @1875 := List.getD.{0} @1857 @1859 @9 @1870 @1879 := fun (__e_n : @24) => - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.root @4 @9 + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.root @4 @9 @1880 := @172 @214 @1882 := @13 @203 @27 @1883 := @18 @100 @@ -958,12 +958,12 @@ @1907 := @1900 @65 @1910 := (h : @216) -> (hs : @96) -> @220 @68 @1912 := @1907 @1845 @93 -@1913 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.denote +@1913 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.denote @1914 := @1913 @29 -@1915 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.__fits_0 +@1915 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.__fits_0 @1916 := @1915 @29 @1919 := @18 (Reasoning.Main.screenDose @29) -@1921 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.root @29 +@1921 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.root @29 @1922 := Ne.{1} @1923 := LexLeanPreservation.Obs @1924 := @1922 @1923 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/RustStd.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/RustStd.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/RustStd.lean index 9c08a94d4..1a204be05 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/RustStd.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -275,4 +275,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7.lean index a571dbbde..0ab321a10 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7.lean @@ -15,7 +15,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7 +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[], [.nat]] }], functions := [ @@ -197,4 +197,4 @@ def denote (x : Nat) : _root_.LexLeanPreservation.Obs := theorem root (x : Nat) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)] (_root_.LexLeanPreservation.Rel (__fits_0 x) (_root_.LexLeanTarget.TargetSyntax.Value.nat (Reasoning.Main.spendLeft x))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 x) -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7 +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7 diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/Compose/RustStd.lex.tex similarity index 93% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/Compose/RustStd.lex.tex rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/Compose/RustStd.lex.tex index 17317d901..9f378ffa2 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/Compose/RustStd.lex.tex +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/Compose/RustStd.lex.tex @@ -1,35 +1,35 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7, - LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7, + LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.__wt_0 : @18 := @398 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.__wt_0 : @18 := @398 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.root : @1017 := @1018 { - all: [LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.root], +theorem LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.root : @1017 := @1018 { + all: [LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.program -@1 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.krate -@2 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.flags +@0 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.program +@1 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.krate +@2 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.flags @3 := Reasoning.Budget.Spend.Step @4 := Nat @5 := @3 @4 @6 := #0 -@8 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.__enc_0 @6 +@8 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.__enc_0 @6 @9 := LexLeanPreservation.Rust.WT @10 := LexLeanTarget.TargetSyntax.Ty.adt @11 := 0 @@ -235,7 +235,7 @@ @421 := LexLeanTarget.TargetSyntax.Expr.value @417 @418 @426 := LexLeanTarget.TargetSyntax.Function.mk @416 @25 @417 @421 @431 := List.getD.{0} @413 @415 @11 @426 -@435 := fun (__e_n : @4) => LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.root @6 @11 +@435 := fun (__e_n : @4) => LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.root @6 @11 @436 := @286 @326 @438 := @15 @315 @30 @439 := @193 @67 @@ -250,12 +250,12 @@ @463 := @456 @25 @466 := (h : @328) -> (hs : @58) -> @331 @230 @468 := @463 @399 @55 -@469 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.denote +@469 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.denote @470 := @469 @32 -@471 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.__fits_0 +@471 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.__fits_0 @472 := @471 @32 @475 := @193 (Reasoning.Main.spendLeft @32) -@477 := LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.root @32 +@477 := LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.root @32 @478 := Bool @479 := Ne.{1} @480 := LexLeanPreservation.Obs diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/RustStd.lean similarity index 99% rename from examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/RustStd.lean rename to examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/RustStd.lean index 077bc85f5..21c9e0208 100644 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/RustStd.lean +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd +namespace LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -195,4 +195,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd +end LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd diff --git a/examples/reasoning/expected/verify/preserve/audit.txt b/examples/reasoning/expected/verify/preserve/audit.txt index 60c30237c..d77d46704 100644 --- a/examples/reasoning/expected/verify/preserve/audit.txt +++ b/examples/reasoning/expected/verify/preserve/audit.txt @@ -7737,87 +7737,87 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_4' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_4' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/reasoning/expected/verify/preserve/preservation.json b/examples/reasoning/expected/verify/preserve/preservation.json index 3a68f8ab5..7ecfeefa0 100644 --- a/examples/reasoning/expected/verify/preserve/preservation.json +++ b/examples/reasoning/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":141533,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":40145,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore","sha256":"a2c0301da210dab60d6803fb6577b079cc7b0312a48216f638bdc6db10742466","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore","sha256":"d6b552e9ea64409ee280d5238150eb4ef9c7a4fbb4dfec223eb691be18900176","target":"rust-core","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"e251d9992ef5291f7e5d639a420026776c9828a97ac3f438265ba2df07af2422","targets":["rust-core"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.root"},{"byte_length":143432,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":40146,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore","sha256":"67e19566c699345d6b60eb67e0959b0da41b47a4ec61b9c1644a67afc9197d94","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore","sha256":"fc3fcbef23fc687eacb7d0ff49fe1ff57083f05ecebaaee69aa5eedfaba3fee8","target":"rust-core","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"f1c4fc5c40775945cd40145dcc66683d73f9f3d361e8d22abd85cf201e290a64","targets":["rust-core"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.root"},{"byte_length":189369,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":52908,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd","sha256":"bcfd58fdb6ba76f2ad1e6755b0ddd53cf3bb033b1d9bbef578319f9d66802afb","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd","sha256":"1f5ca143f0433a7a8e40dcc86279bbd48fea424d7083dc8c11f2e20a4048a3a1","target":"rust-std","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"daff208b855acde6eae0e01133edfb1a6140cb0b8ddb70fe8c1db4d684d62b4f","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.root"},{"byte_length":153403,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":40309,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd","sha256":"b8580d10ad0021ffa286fb659a6a527093f491a2829cb5d2e274edf552910b82","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd","sha256":"d132a127844445892e0a098f5aa86677b57be20556cba2d00e0dd47f25c05b82","target":"rust-std","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"393401ac128d692455975eef5765a53bf9bf446ce2360eee91f43a247d09a900","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.root"},{"byte_length":42541,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":26344,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd","sha256":"cf932715eb80ae8de2cb66f88e54d54e86d373bf9e0ded534418ec355d47ea76","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd","sha256":"220b1ad8412bb6f6f16c4725d8aeebdb2c26727bdc55069ebaa179dd023fa11a","target":"rust-std","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"6f0ff3838fed7fd5983279be7a2feb844d9c4dc493167c6226c859e3ad4bcda5","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.root"},{"byte_length":130194,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":40138,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore","sha256":"c1792bb58d9131a2500fa32081accbc4210ace88d3da5d200014105b0b60f4b1","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore","sha256":"5cdfa0bc29cc62617b372939fc535b119e5feb540bdd1339754a8f2b39ee1b39","target":"rust-core","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"bf749ace929f36f8b2e44415812731d34c075dbf7e447e8990a8555a879d7c1b","targets":["rust-core"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.root"},{"byte_length":115327,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":37686,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd","sha256":"ff497ce3a362480e715eb99221f55974d6e54e20b7e8317ec22fa264538a3957","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd","sha256":"5a2b0e79a485ab69286f85baf018d32e69ccaa6bc60cfc8029938e46dadf59b5","target":"rust-std","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"99dafd6b2949d8ed162f59eac1582098e4919f2e05bea897d20a44c48774726e","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.root"},{"byte_length":60908,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":15068,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd","sha256":"83d2570feae86addb42a386840096221896957032e05971e73b9ece1ba272bb6","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd","sha256":"410f6b0dd5af6a88fab4852a92df79b4114e81936e80869cf67bc8844f388af2","target":"rust-std","theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"f9bf011aa76fa33f4f10a97bab173de85b689587f6b139cca3cbfe533185e5d9","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":141533,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":40145,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore","sha256":"b089a1743ecee9d7b1dfe372daf429f59cba6039f376e65d010ca5cc4ca6abd7","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore","sha256":"129c8839b8251bbc66dd2fa21a346bbead890fc844b16f7324ff6afcbd089ff5","target":"rust-core","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"6d931edd65201a0687e0d78d1935c15a346a7d38943f596025f833150152d7cf","targets":["rust-core"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.root"},{"byte_length":143432,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":40146,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore","sha256":"529947bc5a38deff9a87d8bc5a14383855185160ed44ade11e5aeae2419fa8e6","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore","sha256":"19893039d5fbbeedc9f52e6a164ce1e6446b70f10c4039045d9906fbbdad306d","target":"rust-core","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"7834c82cee2acd672cff509252b95bec2f0f12ff46884943a9c1f625ac2e7fcc","targets":["rust-core"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.root"},{"byte_length":189369,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":52908,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd","sha256":"b14901ef3cd58d847ce5dca6168fec407abae9497aa9113721741e3954ab5ae6","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd","sha256":"afbfe76986b0d469e5614fc48b306b1b26876f07199c3fb4ac2385b5c6082636","target":"rust-std","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"76b25d48d9d1edf0cbae68c88841332997feb4b2d655bec0054cf1b4592c5231","targets":["rust-std"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.root"},{"byte_length":153403,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":40309,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd","sha256":"6eefd5fba3b0d4021345822c01b5d51301032e936850b4604b2e325039b5cb4a","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd","sha256":"a306162189011986ef2c90b655188604a4112124f22f90dfb033defec3becd7d","target":"rust-std","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"6c9228c8b3b6744b319409c747139a28c5af163655e40a7e74da158020a8844f","targets":["rust-std"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.root"},{"byte_length":42541,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":26344,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd","sha256":"4541e31eaede4d4a7f573e96b126f70e4c4a8a97140f4e4194587b37885c0ccf","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd","sha256":"96681239481935f504de7b225ea8444892d518d4d862adf73e45e7fc5a0263cf","target":"rust-std","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"bcd79a067840f7ddc0d73b32e8838d2608b92cdc73aea1252299a4455e51afaf","targets":["rust-std"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.root"},{"byte_length":130194,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":40138,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore","sha256":"d53300edefaa8d26841182eba15b664ea2187c4a3885b14d5cf540cc7fb2dbe7","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore","sha256":"a7ed2c277148fd809c9d5d4bb56dd331b0207321a62559580939dcc7d6188ddd","target":"rust-core","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"f22a6d765489283fa3e793eea7cec2b0489cf27495ad01023e80b258dda6187f","targets":["rust-core"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.root"},{"byte_length":115327,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":37686,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd","sha256":"b539432d995d0bbcf9302ce8327f8d3d8ba845b52d242b9ac45293f36c596042","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd","sha256":"5d1d9f62e2792847747ff765814ae09c7be0983d364c5d612f147aef75e8902e","target":"rust-std","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"5dfd49f7e2dd83f51809de21adeaedbd6a8eba782c0bc569b8d1a066e914c698","targets":["rust-std"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.root"},{"byte_length":60908,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":15068,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd","sha256":"7ed552224ba31baed07621950405e64028d1d6fc8293ac958f6262a526e3ae14","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd","sha256":"76d8befc3d155bc5f8c31abfe93e925d7a8bce5dc47470ba0ca7bfcb33a9f618","target":"rust-std","theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"5e5b338db6fc83467192cc3661ae644f6892e2c35f2445b3d4bdd164a0b7a985","targets":["rust-std"],"theorem":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/reasoning/expected/verify/probe/LexLeanProbe.P7b45b58d681c076cfd69727310b65f3f.lean b/examples/reasoning/expected/verify/probe/LexLeanProbe.P02b315b69b8881ec6f91f78f9b12c608.lean similarity index 100% rename from examples/reasoning/expected/verify/probe/LexLeanProbe.P7b45b58d681c076cfd69727310b65f3f.lean rename to examples/reasoning/expected/verify/probe/LexLeanProbe.P02b315b69b8881ec6f91f78f9b12c608.lean diff --git a/examples/reasoning/expected/verify/probe/process.json b/examples/reasoning/expected/verify/probe/process.json index e14ea9ef8..1216aaa4c 100644 --- a/examples/reasoning/expected/verify/probe/process.json +++ b/examples/reasoning/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P7b45b58d681c076cfd69727310b65f3f.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P7b45b58d681c076cfd69727310b65f3f","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P02b315b69b8881ec6f91f78f9b12c608.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P02b315b69b8881ec6f91f78f9b12c608","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json new file mode 100644 index 000000000..098b97db7 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json new file mode 100644 index 000000000..13ef2e0f4 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json new file mode 100644 index 000000000..8880a3355 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json new file mode 100644 index 000000000..47b59b2b5 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json new file mode 100644 index 000000000..d69078f1e --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json new file mode 100644 index 000000000..29bda675a --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json new file mode 100644 index 000000000..e04b1e379 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json new file mode 100644 index 000000000..16f582ad6 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json new file mode 100644 index 000000000..ab53d107a --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json new file mode 100644 index 000000000..1146b3f34 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json new file mode 100644 index 000000000..12fe79e27 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json new file mode 100644 index 000000000..094c6de1e --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json new file mode 100644 index 000000000..8903687f6 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json new file mode 100644 index 000000000..2d9843094 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json new file mode 100644 index 000000000..e206c1cb5 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json new file mode 100644 index 000000000..c0bc45f93 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json new file mode 100644 index 000000000..f868587fe --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json new file mode 100644 index 000000000..cbfa005e6 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json new file mode 100644 index 000000000..74182dad8 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json new file mode 100644 index 000000000..652200608 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json new file mode 100644 index 000000000..8f1fd30be --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json new file mode 100644 index 000000000..d8443528a --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json new file mode 100644 index 000000000..43e2391e4 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json new file mode 100644 index 000000000..780a3ff52 --- /dev/null +++ b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json deleted file mode 100644 index a67cd3ee4..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json deleted file mode 100644 index 1ef37e986..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json deleted file mode 100644 index 2444c2cc6..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json deleted file mode 100644 index 496283d50..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json deleted file mode 100644 index 18d720c9e..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json deleted file mode 100644 index d911e017d..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json deleted file mode 100644 index 9211f1fb1..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json deleted file mode 100644 index a1482de10..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json deleted file mode 100644 index 3b620d78e..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json deleted file mode 100644 index 1b215d593..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json deleted file mode 100644 index bccf0faec..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json deleted file mode 100644 index d83a6bf0f..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json deleted file mode 100644 index 9d5e159d5..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json deleted file mode 100644 index 135978343..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json deleted file mode 100644 index 5cbddad88..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json deleted file mode 100644 index c218ebba3..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json deleted file mode 100644 index 95a96a15e..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json deleted file mode 100644 index 7128fba45..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json deleted file mode 100644 index d9d4d708c..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json deleted file mode 100644 index 4b2223648..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json deleted file mode 100644 index b2677f2d7..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json deleted file mode 100644 index 195c0699c..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json deleted file mode 100644 index 0a13ff000..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json b/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json deleted file mode 100644 index 048d58fbf..000000000 --- a/examples/reasoning/expected/verify/process/leanchecker/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 24b2f415b..99ee76c4d 100644 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_4' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"7c47fa4c01a1a6db3a11d32c7ab86849804a5d67eecf706a6db243d8f0be8297","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_4' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"026749d82ce4aa383351e2ae3e4c64b890d92b8689cb61f9e869bf20c7e401a9","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json new file mode 100644 index 000000000..dd74493e6 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json new file mode 100644 index 000000000..f43b718b4 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json new file mode 100644 index 000000000..4d95737c4 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json new file mode 100644 index 000000000..f128aa611 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json new file mode 100644 index 000000000..c53a337e0 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json new file mode 100644 index 000000000..77aad317d --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json new file mode 100644 index 000000000..1257f7f74 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json new file mode 100644 index 000000000..dc02d542b --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json new file mode 100644 index 000000000..736edce7b --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json new file mode 100644 index 000000000..48e5ee084 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json new file mode 100644 index 000000000..c3d71932c --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json new file mode 100644 index 000000000..7de2799da --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json new file mode 100644 index 000000000..60df568e5 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json new file mode 100644 index 000000000..28d7d3f8d --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json new file mode 100644 index 000000000..d04847389 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json new file mode 100644 index 000000000..d97bd345c --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json new file mode 100644 index 000000000..d98df0439 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json new file mode 100644 index 000000000..d80a55f71 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json new file mode 100644 index 000000000..26656434f --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json new file mode 100644 index 000000000..98e919499 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json new file mode 100644 index 000000000..754105252 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json new file mode 100644 index 000000000..3999bcd41 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json new file mode 100644 index 000000000..8fc9a7579 --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json new file mode 100644 index 000000000..5a822a4fe --- /dev/null +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7.olean","$STAGING/preserve-src/LexLeanPreserve/C02b315b69b8881ec6f91f78f9b12c608/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C02b315b69b8881ec6f91f78f9b12c608.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json deleted file mode 100644 index 728b929d0..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json deleted file mode 100644 index ee925f2a1..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json deleted file mode 100644 index ac2bf15f4..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json deleted file mode 100644 index 36ee3028d..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json deleted file mode 100644 index a48606b4b..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json deleted file mode 100644 index 827a446a5..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json deleted file mode 100644 index be7aef3bb..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json deleted file mode 100644 index 715f237b4..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json deleted file mode 100644 index 5b38add1c..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json deleted file mode 100644 index 01b8c10cd..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json deleted file mode 100644 index 9cbd12390..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json deleted file mode 100644 index d8cb7b171..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json deleted file mode 100644 index 5b8770eea..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json deleted file mode 100644 index 8922ff500..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json deleted file mode 100644 index 768374708..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json deleted file mode 100644 index 913dc7f9a..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/Compose/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/Compose/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.Compose.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json deleted file mode 100644 index a59657ac2..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/RustCore.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5/RustCore.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.RustCore","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json deleted file mode 100644 index f63026e60..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json deleted file mode 100644 index 678d683e7..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json deleted file mode 100644 index 29f8c7463..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json deleted file mode 100644 index 1bfb331e8..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json deleted file mode 100644 index 4815ab8c6..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json deleted file mode 100644 index c7256d1b4..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json deleted file mode 100644 index 2cda6d584..000000000 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7.olean","$STAGING/preserve-src/LexLeanPreserve/C7b45b58d681c076cfd69727310b65f3f/R7.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C7b45b58d681c076cfd69727310b65f3f.R7","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/reasoning/lexlean.lock b/examples/reasoning/lexlean.lock index 3d30e1a9d..b885c1e88 100644 --- a/examples/reasoning/lexlean.lock +++ b/examples/reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursion/expected/build/manifest.json b/examples/recursion/expected/build/manifest.json index fc83244c8..0d7d5769f 100644 --- a/examples/recursion/expected/build/manifest.json +++ b/examples/recursion/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"33460eecaeb5b7f44bb132875535087f12233636373d66b5581d457ad89a7d1c","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"38059195c40d8b2d04ddc4fb83d944ef4ad4b474a851be2fb8989a1bb7659c56"},{"byte_length":640,"kind":"project-config","path":"lexlean.toml","sha256":"b8201330ef8609d8f53e24e2fa367697675b98d69ba844d6a75adffe84a88319"},{"byte_length":12276,"kind":"source","path":"src/Main.lex.tex","sha256":"621026825ab06b16f9a9216cb265b5789461525445908563bfcad4d5d42429cc"},{"byte_length":861,"kind":"source","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Recursion.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Recursion.Syntax","module":"Syntax","source_path":"src/Syntax.lex.tex"}],"outputs":[{"byte_length":16931,"kind":"coverage","path":"coverage/Recursion/Main.coverage.json","sha256":"c13cea825261ba24cbd8c97926de1526197431862fc4056b10d22c1a07fc50e3"},{"byte_length":7661,"kind":"coverage","path":"coverage/Recursion/Syntax.coverage.json","sha256":"ae25a6b2719475a6be93ea19b2c06d5cab04e4e113d84484061047fc72acd3c0"},{"byte_length":35346,"kind":"lean","path":"modules/Recursion/Main.lean","sha256":"8d70ac7dc493644bf6f756c9eb58a607b62dcd1540e2a7928ef2dac66d70f21d"},{"byte_length":622,"kind":"lean","path":"modules/Recursion/Syntax.lean","sha256":"56aa3cba170de2a0b3a833c67a218d72162956271df211c97d7357234a7eb0b1"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Syntax.closure.json","sha256":"37a0e650d18d332b85cdcc97c6e3a86ffc1dbb591bace0b323fc8bf535336f8b"},{"byte_length":12708,"kind":"map","path":"maps/Recursion/Main.map.json","sha256":"c35e5e7b5a6b680dcab6d2361e294f194ef7e515f2d013ca6abd35e876672fdb"},{"byte_length":2282,"kind":"map","path":"maps/Recursion/Syntax.map.json","sha256":"351a872da45d20a18829070fb5b959d84cb52c9caf9c2ac0ac0bf733696e3396"},{"byte_length":17821,"kind":"tex","path":"modules/Recursion/Main.tex","sha256":"765d086267d45138f4fb9de710ccbe74ba93a4c46f3c19c24d382e209b4b4672"},{"byte_length":1093,"kind":"tex","path":"modules/Recursion/Syntax.tex","sha256":"24391ae507ff036ad50cbece531289a033ddff326046c24e85c3968beb127bea"}],"project":"recursion","selection":["Main","Syntax"],"semantic_id":"fca4cff7cd9d7d680879d32a7e810d91c6e198c93439d128535481c2ae7ad87d","source_id":"62841407e4d24dbc405b6385f58d291e6ddcd3f2a35fd992a8b58630e43a3912","spec":"lexlean/build-manifest/1"} +{"build_id":"187d63003b0a36a92f2bb7e9a33dc541316bc207979ef046bd60f48993161564","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"3ecb9e05a43173093430ad18ab3d49698c874ca01b1bcd7c47c3de7cb5fccd69"},{"byte_length":640,"kind":"project-config","path":"lexlean.toml","sha256":"b8201330ef8609d8f53e24e2fa367697675b98d69ba844d6a75adffe84a88319"},{"byte_length":12276,"kind":"source","path":"src/Main.lex.tex","sha256":"621026825ab06b16f9a9216cb265b5789461525445908563bfcad4d5d42429cc"},{"byte_length":861,"kind":"source","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"Recursion.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"Recursion.Syntax","module":"Syntax","source_path":"src/Syntax.lex.tex"}],"outputs":[{"byte_length":16931,"kind":"coverage","path":"coverage/Recursion/Main.coverage.json","sha256":"c13cea825261ba24cbd8c97926de1526197431862fc4056b10d22c1a07fc50e3"},{"byte_length":7661,"kind":"coverage","path":"coverage/Recursion/Syntax.coverage.json","sha256":"ae25a6b2719475a6be93ea19b2c06d5cab04e4e113d84484061047fc72acd3c0"},{"byte_length":35346,"kind":"lean","path":"modules/Recursion/Main.lean","sha256":"8d70ac7dc493644bf6f756c9eb58a607b62dcd1540e2a7928ef2dac66d70f21d"},{"byte_length":622,"kind":"lean","path":"modules/Recursion/Syntax.lean","sha256":"56aa3cba170de2a0b3a833c67a218d72162956271df211c97d7357234a7eb0b1"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10604,"kind":"lexicon-closure","path":"lexicons/Syntax.closure.json","sha256":"37a0e650d18d332b85cdcc97c6e3a86ffc1dbb591bace0b323fc8bf535336f8b"},{"byte_length":12708,"kind":"map","path":"maps/Recursion/Main.map.json","sha256":"776ee3429450e1b018d70941553601b4e79e542c0b0c31e990072cb0911ef478"},{"byte_length":2282,"kind":"map","path":"maps/Recursion/Syntax.map.json","sha256":"d731a2c7d51432762ae3041039f9bbe5f772d55f6e70f522a844c48ffe05d28f"},{"byte_length":17821,"kind":"tex","path":"modules/Recursion/Main.tex","sha256":"765d086267d45138f4fb9de710ccbe74ba93a4c46f3c19c24d382e209b4b4672"},{"byte_length":1093,"kind":"tex","path":"modules/Recursion/Syntax.tex","sha256":"24391ae507ff036ad50cbece531289a033ddff326046c24e85c3968beb127bea"}],"project":"recursion","selection":["Main","Syntax"],"semantic_id":"d478905735ed8adb7e0e1e617ced36dbb99b24d527400467981dfe38faea5841","source_id":"2f0ffdf34707ae74d9ea7bde2e298a2515e325f54a1de20fa2301e60a4e6656a","spec":"lexlean/build-manifest/1"} diff --git a/examples/recursion/expected/build/maps/Recursion/Main.map.json b/examples/recursion/expected/build/maps/Recursion/Main.map.json index d86400b84..5dc40435d 100644 --- a/examples/recursion/expected/build/maps/Recursion/Main.map.json +++ b/examples/recursion/expected/build/maps/Recursion/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Recursion/Main.lean"},{"id":1,"kind":"tex","path":"modules/Recursion/Main.tex"}],"mappings":[{"artifact":0,"gen_end":300,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":0,"gen_end":518,"gen_start":300,"node":1,"role":"declaration","source":0,"src_end":396,"src_start":135},{"artifact":0,"gen_end":765,"gen_start":518,"node":2,"role":"declaration","source":0,"src_end":703,"src_start":398},{"artifact":0,"gen_end":1132,"gen_start":765,"node":3,"role":"declaration","source":0,"src_end":1092,"src_start":705},{"artifact":0,"gen_end":1365,"gen_start":1132,"node":4,"role":"declaration","source":0,"src_end":1375,"src_start":1094},{"artifact":0,"gen_end":1666,"gen_start":1365,"node":5,"role":"declaration","source":0,"src_end":1869,"src_start":1377},{"artifact":0,"gen_end":1833,"gen_start":1666,"node":6,"role":"declaration","source":0,"src_end":2076,"src_start":1871},{"artifact":0,"gen_end":1998,"gen_start":1833,"node":7,"role":"declaration","source":0,"src_end":2284,"src_start":2078},{"artifact":0,"gen_end":5081,"gen_start":1998,"node":8,"role":"declaration","source":0,"src_end":2515,"src_start":2286},{"artifact":0,"gen_end":5494,"gen_start":5081,"node":9,"role":"declaration","source":0,"src_end":2805,"src_start":2517},{"artifact":0,"gen_end":8614,"gen_start":5494,"node":10,"role":"declaration","source":0,"src_end":3065,"src_start":2807},{"artifact":0,"gen_end":9129,"gen_start":8614,"node":11,"role":"declaration","source":0,"src_end":3398,"src_start":3067},{"artifact":0,"gen_end":12310,"gen_start":9129,"node":12,"role":"declaration","source":0,"src_end":3705,"src_start":3400},{"artifact":0,"gen_end":12857,"gen_start":12310,"node":13,"role":"declaration","source":0,"src_end":4042,"src_start":3707},{"artifact":0,"gen_end":13155,"gen_start":12857,"node":14,"role":"declaration","source":0,"src_end":4339,"src_start":4044},{"artifact":0,"gen_end":13461,"gen_start":13155,"node":15,"role":"declaration","source":0,"src_end":4646,"src_start":4341},{"artifact":0,"gen_end":13527,"gen_start":13461,"node":16,"role":"declaration","source":0,"src_end":4740,"src_start":4648},{"artifact":0,"gen_end":13599,"gen_start":13527,"node":17,"role":"declaration","source":0,"src_end":4881,"src_start":4742},{"artifact":0,"gen_end":13674,"gen_start":13599,"node":18,"role":"declaration","source":0,"src_end":5025,"src_start":4883},{"artifact":0,"gen_end":13746,"gen_start":13674,"node":19,"role":"declaration","source":0,"src_end":5164,"src_start":5027},{"artifact":0,"gen_end":13958,"gen_start":13746,"node":20,"role":"declaration","source":0,"src_end":5429,"src_start":5166},{"artifact":0,"gen_end":17187,"gen_start":13958,"node":21,"role":"declaration","source":0,"src_end":5791,"src_start":5431},{"artifact":0,"gen_end":20539,"gen_start":17187,"node":22,"role":"declaration","source":0,"src_end":6267,"src_start":5793},{"artifact":0,"gen_end":21432,"gen_start":20539,"node":23,"role":"declaration","source":0,"src_end":6889,"src_start":6269},{"artifact":0,"gen_end":21677,"gen_start":21432,"node":24,"role":"declaration","source":0,"src_end":7181,"src_start":6891},{"artifact":0,"gen_end":24987,"gen_start":21677,"node":25,"role":"declaration","source":0,"src_end":7621,"src_start":7183},{"artifact":0,"gen_end":25744,"gen_start":24987,"node":26,"role":"declaration","source":0,"src_end":8130,"src_start":7623},{"artifact":0,"gen_end":25977,"gen_start":25744,"node":27,"role":"declaration","source":0,"src_end":8410,"src_start":8132},{"artifact":0,"gen_end":27070,"gen_start":25977,"node":28,"role":"declaration","source":0,"src_end":9533,"src_start":8412},{"artifact":0,"gen_end":27363,"gen_start":27070,"node":29,"role":"declaration","source":0,"src_end":9869,"src_start":9535},{"artifact":0,"gen_end":27752,"gen_start":27363,"node":30,"role":"declaration","source":0,"src_end":10494,"src_start":9871},{"artifact":0,"gen_end":28363,"gen_start":27752,"node":31,"role":"declaration","source":0,"src_end":11051,"src_start":10496},{"artifact":0,"gen_end":31414,"gen_start":28363,"node":32,"role":"declaration","source":0,"src_end":11266,"src_start":11053},{"artifact":0,"gen_end":34541,"gen_start":31414,"node":33,"role":"declaration","source":0,"src_end":11529,"src_start":11268},{"artifact":0,"gen_end":34889,"gen_start":34541,"node":34,"role":"declaration","source":0,"src_end":11810,"src_start":11531},{"artifact":0,"gen_end":35266,"gen_start":34889,"node":35,"role":"declaration","source":0,"src_end":12109,"src_start":11812},{"artifact":0,"gen_end":35326,"gen_start":35266,"node":36,"role":"declaration","source":0,"src_end":12240,"src_start":12111},{"artifact":0,"gen_end":35346,"gen_start":35326,"node":0,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":37,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":1,"gen_end":624,"gen_start":134,"node":38,"role":"declaration","source":0,"src_end":396,"src_start":135},{"artifact":1,"gen_end":1143,"gen_start":624,"node":39,"role":"declaration","source":0,"src_end":703,"src_start":398},{"artifact":1,"gen_end":1746,"gen_start":1143,"node":40,"role":"declaration","source":0,"src_end":1092,"src_start":705},{"artifact":1,"gen_end":2223,"gen_start":1746,"node":41,"role":"declaration","source":0,"src_end":1375,"src_start":1094},{"artifact":1,"gen_end":2765,"gen_start":2223,"node":42,"role":"declaration","source":0,"src_end":1869,"src_start":1377},{"artifact":1,"gen_end":3165,"gen_start":2765,"node":43,"role":"declaration","source":0,"src_end":2076,"src_start":1871},{"artifact":1,"gen_end":3566,"gen_start":3165,"node":44,"role":"declaration","source":0,"src_end":2284,"src_start":2078},{"artifact":1,"gen_end":3908,"gen_start":3566,"node":45,"role":"declaration","source":0,"src_end":2515,"src_start":2286},{"artifact":1,"gen_end":4410,"gen_start":3908,"node":46,"role":"declaration","source":0,"src_end":2805,"src_start":2517},{"artifact":1,"gen_end":4790,"gen_start":4410,"node":47,"role":"declaration","source":0,"src_end":3065,"src_start":2807},{"artifact":1,"gen_end":5389,"gen_start":4790,"node":48,"role":"declaration","source":0,"src_end":3398,"src_start":3067},{"artifact":1,"gen_end":5830,"gen_start":5389,"node":49,"role":"declaration","source":0,"src_end":3705,"src_start":3400},{"artifact":1,"gen_end":6390,"gen_start":5830,"node":50,"role":"declaration","source":0,"src_end":4042,"src_start":3707},{"artifact":1,"gen_end":6798,"gen_start":6390,"node":51,"role":"declaration","source":0,"src_end":4339,"src_start":4044},{"artifact":1,"gen_end":7214,"gen_start":6798,"node":52,"role":"declaration","source":0,"src_end":4646,"src_start":4341},{"artifact":1,"gen_end":7388,"gen_start":7214,"node":53,"role":"declaration","source":0,"src_end":4740,"src_start":4648},{"artifact":1,"gen_end":7590,"gen_start":7388,"node":54,"role":"declaration","source":0,"src_end":4881,"src_start":4742},{"artifact":1,"gen_end":7796,"gen_start":7590,"node":55,"role":"declaration","source":0,"src_end":5025,"src_start":4883},{"artifact":1,"gen_end":7998,"gen_start":7796,"node":56,"role":"declaration","source":0,"src_end":5164,"src_start":5027},{"artifact":1,"gen_end":8407,"gen_start":7998,"node":57,"role":"declaration","source":0,"src_end":5429,"src_start":5166},{"artifact":1,"gen_end":8875,"gen_start":8407,"node":58,"role":"declaration","source":0,"src_end":5791,"src_start":5431},{"artifact":1,"gen_end":9466,"gen_start":8875,"node":59,"role":"declaration","source":0,"src_end":6267,"src_start":5793},{"artifact":1,"gen_end":10390,"gen_start":9466,"node":60,"role":"declaration","source":0,"src_end":6889,"src_start":6269},{"artifact":1,"gen_end":10765,"gen_start":10390,"node":61,"role":"declaration","source":0,"src_end":7181,"src_start":6891},{"artifact":1,"gen_end":11314,"gen_start":10765,"node":62,"role":"declaration","source":0,"src_end":7621,"src_start":7183},{"artifact":1,"gen_end":12104,"gen_start":11314,"node":63,"role":"declaration","source":0,"src_end":8130,"src_start":7623},{"artifact":1,"gen_end":12467,"gen_start":12104,"node":64,"role":"declaration","source":0,"src_end":8410,"src_start":8132},{"artifact":1,"gen_end":13865,"gen_start":12467,"node":65,"role":"declaration","source":0,"src_end":9533,"src_start":8412},{"artifact":1,"gen_end":14464,"gen_start":13865,"node":66,"role":"declaration","source":0,"src_end":9869,"src_start":9535},{"artifact":1,"gen_end":15155,"gen_start":14464,"node":67,"role":"declaration","source":0,"src_end":10494,"src_start":9871},{"artifact":1,"gen_end":15876,"gen_start":15155,"node":68,"role":"declaration","source":0,"src_end":11051,"src_start":10496},{"artifact":1,"gen_end":16188,"gen_start":15876,"node":69,"role":"declaration","source":0,"src_end":11266,"src_start":11053},{"artifact":1,"gen_end":16576,"gen_start":16188,"node":70,"role":"declaration","source":0,"src_end":11529,"src_start":11268},{"artifact":1,"gen_end":17080,"gen_start":16576,"node":71,"role":"declaration","source":0,"src_end":11810,"src_start":11531},{"artifact":1,"gen_end":17616,"gen_start":17080,"node":72,"role":"declaration","source":0,"src_end":12109,"src_start":11812},{"artifact":1,"gen_end":17806,"gen_start":17616,"node":73,"role":"declaration","source":0,"src_end":12240,"src_start":12111},{"artifact":1,"gen_end":17821,"gen_start":17806,"node":37,"role":"declaration","source":0,"src_end":12276,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-latex-module"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"}],"semantic_id":"fca4cff7cd9d7d680879d32a7e810d91c6e198c93439d128535481c2ae7ad87d","source_id":"62841407e4d24dbc405b6385f58d291e6ddcd3f2a35fd992a8b58630e43a3912","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"621026825ab06b16f9a9216cb265b5789461525445908563bfcad4d5d42429cc"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Recursion/Main.lean"},{"id":1,"kind":"tex","path":"modules/Recursion/Main.tex"}],"mappings":[{"artifact":0,"gen_end":300,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":0,"gen_end":518,"gen_start":300,"node":1,"role":"declaration","source":0,"src_end":396,"src_start":135},{"artifact":0,"gen_end":765,"gen_start":518,"node":2,"role":"declaration","source":0,"src_end":703,"src_start":398},{"artifact":0,"gen_end":1132,"gen_start":765,"node":3,"role":"declaration","source":0,"src_end":1092,"src_start":705},{"artifact":0,"gen_end":1365,"gen_start":1132,"node":4,"role":"declaration","source":0,"src_end":1375,"src_start":1094},{"artifact":0,"gen_end":1666,"gen_start":1365,"node":5,"role":"declaration","source":0,"src_end":1869,"src_start":1377},{"artifact":0,"gen_end":1833,"gen_start":1666,"node":6,"role":"declaration","source":0,"src_end":2076,"src_start":1871},{"artifact":0,"gen_end":1998,"gen_start":1833,"node":7,"role":"declaration","source":0,"src_end":2284,"src_start":2078},{"artifact":0,"gen_end":5081,"gen_start":1998,"node":8,"role":"declaration","source":0,"src_end":2515,"src_start":2286},{"artifact":0,"gen_end":5494,"gen_start":5081,"node":9,"role":"declaration","source":0,"src_end":2805,"src_start":2517},{"artifact":0,"gen_end":8614,"gen_start":5494,"node":10,"role":"declaration","source":0,"src_end":3065,"src_start":2807},{"artifact":0,"gen_end":9129,"gen_start":8614,"node":11,"role":"declaration","source":0,"src_end":3398,"src_start":3067},{"artifact":0,"gen_end":12310,"gen_start":9129,"node":12,"role":"declaration","source":0,"src_end":3705,"src_start":3400},{"artifact":0,"gen_end":12857,"gen_start":12310,"node":13,"role":"declaration","source":0,"src_end":4042,"src_start":3707},{"artifact":0,"gen_end":13155,"gen_start":12857,"node":14,"role":"declaration","source":0,"src_end":4339,"src_start":4044},{"artifact":0,"gen_end":13461,"gen_start":13155,"node":15,"role":"declaration","source":0,"src_end":4646,"src_start":4341},{"artifact":0,"gen_end":13527,"gen_start":13461,"node":16,"role":"declaration","source":0,"src_end":4740,"src_start":4648},{"artifact":0,"gen_end":13599,"gen_start":13527,"node":17,"role":"declaration","source":0,"src_end":4881,"src_start":4742},{"artifact":0,"gen_end":13674,"gen_start":13599,"node":18,"role":"declaration","source":0,"src_end":5025,"src_start":4883},{"artifact":0,"gen_end":13746,"gen_start":13674,"node":19,"role":"declaration","source":0,"src_end":5164,"src_start":5027},{"artifact":0,"gen_end":13958,"gen_start":13746,"node":20,"role":"declaration","source":0,"src_end":5429,"src_start":5166},{"artifact":0,"gen_end":17187,"gen_start":13958,"node":21,"role":"declaration","source":0,"src_end":5791,"src_start":5431},{"artifact":0,"gen_end":20539,"gen_start":17187,"node":22,"role":"declaration","source":0,"src_end":6267,"src_start":5793},{"artifact":0,"gen_end":21432,"gen_start":20539,"node":23,"role":"declaration","source":0,"src_end":6889,"src_start":6269},{"artifact":0,"gen_end":21677,"gen_start":21432,"node":24,"role":"declaration","source":0,"src_end":7181,"src_start":6891},{"artifact":0,"gen_end":24987,"gen_start":21677,"node":25,"role":"declaration","source":0,"src_end":7621,"src_start":7183},{"artifact":0,"gen_end":25744,"gen_start":24987,"node":26,"role":"declaration","source":0,"src_end":8130,"src_start":7623},{"artifact":0,"gen_end":25977,"gen_start":25744,"node":27,"role":"declaration","source":0,"src_end":8410,"src_start":8132},{"artifact":0,"gen_end":27070,"gen_start":25977,"node":28,"role":"declaration","source":0,"src_end":9533,"src_start":8412},{"artifact":0,"gen_end":27363,"gen_start":27070,"node":29,"role":"declaration","source":0,"src_end":9869,"src_start":9535},{"artifact":0,"gen_end":27752,"gen_start":27363,"node":30,"role":"declaration","source":0,"src_end":10494,"src_start":9871},{"artifact":0,"gen_end":28363,"gen_start":27752,"node":31,"role":"declaration","source":0,"src_end":11051,"src_start":10496},{"artifact":0,"gen_end":31414,"gen_start":28363,"node":32,"role":"declaration","source":0,"src_end":11266,"src_start":11053},{"artifact":0,"gen_end":34541,"gen_start":31414,"node":33,"role":"declaration","source":0,"src_end":11529,"src_start":11268},{"artifact":0,"gen_end":34889,"gen_start":34541,"node":34,"role":"declaration","source":0,"src_end":11810,"src_start":11531},{"artifact":0,"gen_end":35266,"gen_start":34889,"node":35,"role":"declaration","source":0,"src_end":12109,"src_start":11812},{"artifact":0,"gen_end":35326,"gen_start":35266,"node":36,"role":"declaration","source":0,"src_end":12240,"src_start":12111},{"artifact":0,"gen_end":35346,"gen_start":35326,"node":0,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":37,"role":"declaration","source":0,"src_end":12276,"src_start":0},{"artifact":1,"gen_end":624,"gen_start":134,"node":38,"role":"declaration","source":0,"src_end":396,"src_start":135},{"artifact":1,"gen_end":1143,"gen_start":624,"node":39,"role":"declaration","source":0,"src_end":703,"src_start":398},{"artifact":1,"gen_end":1746,"gen_start":1143,"node":40,"role":"declaration","source":0,"src_end":1092,"src_start":705},{"artifact":1,"gen_end":2223,"gen_start":1746,"node":41,"role":"declaration","source":0,"src_end":1375,"src_start":1094},{"artifact":1,"gen_end":2765,"gen_start":2223,"node":42,"role":"declaration","source":0,"src_end":1869,"src_start":1377},{"artifact":1,"gen_end":3165,"gen_start":2765,"node":43,"role":"declaration","source":0,"src_end":2076,"src_start":1871},{"artifact":1,"gen_end":3566,"gen_start":3165,"node":44,"role":"declaration","source":0,"src_end":2284,"src_start":2078},{"artifact":1,"gen_end":3908,"gen_start":3566,"node":45,"role":"declaration","source":0,"src_end":2515,"src_start":2286},{"artifact":1,"gen_end":4410,"gen_start":3908,"node":46,"role":"declaration","source":0,"src_end":2805,"src_start":2517},{"artifact":1,"gen_end":4790,"gen_start":4410,"node":47,"role":"declaration","source":0,"src_end":3065,"src_start":2807},{"artifact":1,"gen_end":5389,"gen_start":4790,"node":48,"role":"declaration","source":0,"src_end":3398,"src_start":3067},{"artifact":1,"gen_end":5830,"gen_start":5389,"node":49,"role":"declaration","source":0,"src_end":3705,"src_start":3400},{"artifact":1,"gen_end":6390,"gen_start":5830,"node":50,"role":"declaration","source":0,"src_end":4042,"src_start":3707},{"artifact":1,"gen_end":6798,"gen_start":6390,"node":51,"role":"declaration","source":0,"src_end":4339,"src_start":4044},{"artifact":1,"gen_end":7214,"gen_start":6798,"node":52,"role":"declaration","source":0,"src_end":4646,"src_start":4341},{"artifact":1,"gen_end":7388,"gen_start":7214,"node":53,"role":"declaration","source":0,"src_end":4740,"src_start":4648},{"artifact":1,"gen_end":7590,"gen_start":7388,"node":54,"role":"declaration","source":0,"src_end":4881,"src_start":4742},{"artifact":1,"gen_end":7796,"gen_start":7590,"node":55,"role":"declaration","source":0,"src_end":5025,"src_start":4883},{"artifact":1,"gen_end":7998,"gen_start":7796,"node":56,"role":"declaration","source":0,"src_end":5164,"src_start":5027},{"artifact":1,"gen_end":8407,"gen_start":7998,"node":57,"role":"declaration","source":0,"src_end":5429,"src_start":5166},{"artifact":1,"gen_end":8875,"gen_start":8407,"node":58,"role":"declaration","source":0,"src_end":5791,"src_start":5431},{"artifact":1,"gen_end":9466,"gen_start":8875,"node":59,"role":"declaration","source":0,"src_end":6267,"src_start":5793},{"artifact":1,"gen_end":10390,"gen_start":9466,"node":60,"role":"declaration","source":0,"src_end":6889,"src_start":6269},{"artifact":1,"gen_end":10765,"gen_start":10390,"node":61,"role":"declaration","source":0,"src_end":7181,"src_start":6891},{"artifact":1,"gen_end":11314,"gen_start":10765,"node":62,"role":"declaration","source":0,"src_end":7621,"src_start":7183},{"artifact":1,"gen_end":12104,"gen_start":11314,"node":63,"role":"declaration","source":0,"src_end":8130,"src_start":7623},{"artifact":1,"gen_end":12467,"gen_start":12104,"node":64,"role":"declaration","source":0,"src_end":8410,"src_start":8132},{"artifact":1,"gen_end":13865,"gen_start":12467,"node":65,"role":"declaration","source":0,"src_end":9533,"src_start":8412},{"artifact":1,"gen_end":14464,"gen_start":13865,"node":66,"role":"declaration","source":0,"src_end":9869,"src_start":9535},{"artifact":1,"gen_end":15155,"gen_start":14464,"node":67,"role":"declaration","source":0,"src_end":10494,"src_start":9871},{"artifact":1,"gen_end":15876,"gen_start":15155,"node":68,"role":"declaration","source":0,"src_end":11051,"src_start":10496},{"artifact":1,"gen_end":16188,"gen_start":15876,"node":69,"role":"declaration","source":0,"src_end":11266,"src_start":11053},{"artifact":1,"gen_end":16576,"gen_start":16188,"node":70,"role":"declaration","source":0,"src_end":11529,"src_start":11268},{"artifact":1,"gen_end":17080,"gen_start":16576,"node":71,"role":"declaration","source":0,"src_end":11810,"src_start":11531},{"artifact":1,"gen_end":17616,"gen_start":17080,"node":72,"role":"declaration","source":0,"src_end":12109,"src_start":11812},{"artifact":1,"gen_end":17806,"gen_start":17616,"node":73,"role":"declaration","source":0,"src_end":12240,"src_start":12111},{"artifact":1,"gen_end":17821,"gen_start":17806,"node":37,"role":"declaration","source":0,"src_end":12276,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-latex-module"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-declaration"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"}],"semantic_id":"d478905735ed8adb7e0e1e617ced36dbb99b24d527400467981dfe38faea5841","source_id":"2f0ffdf34707ae74d9ea7bde2e298a2515e325f54a1de20fa2301e60a4e6656a","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"621026825ab06b16f9a9216cb265b5789461525445908563bfcad4d5d42429cc"}],"spec":"lexlean/source-map/1"} diff --git a/examples/recursion/expected/build/maps/Recursion/Syntax.map.json b/examples/recursion/expected/build/maps/Recursion/Syntax.map.json index da0e29a47..d85522290 100644 --- a/examples/recursion/expected/build/maps/Recursion/Syntax.map.json +++ b/examples/recursion/expected/build/maps/Recursion/Syntax.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/Recursion/Syntax.lean"},{"id":1,"kind":"tex","path":"modules/Recursion/Syntax.tex"}],"mappings":[{"artifact":0,"gen_end":199,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":0,"gen_end":287,"gen_start":199,"node":1,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":0,"gen_end":415,"gen_start":287,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":0,"gen_end":518,"gen_start":415,"node":3,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":0,"gen_end":600,"gen_start":518,"node":4,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":0,"gen_end":622,"gen_start":600,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":328,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":1,"gen_end":637,"gen_start":328,"node":7,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":1,"gen_end":886,"gen_start":637,"node":8,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":1,"gen_end":1078,"gen_start":886,"node":9,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":1,"gen_end":1093,"gen_start":1078,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0}],"module":"Syntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"fca4cff7cd9d7d680879d32a7e810d91c6e198c93439d128535481c2ae7ad87d","source_id":"62841407e4d24dbc405b6385f58d291e6ddcd3f2a35fd992a8b58630e43a3912","sources":[{"id":0,"kind":"file","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/Recursion/Syntax.lean"},{"id":1,"kind":"tex","path":"modules/Recursion/Syntax.tex"}],"mappings":[{"artifact":0,"gen_end":199,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":0,"gen_end":287,"gen_start":199,"node":1,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":0,"gen_end":415,"gen_start":287,"node":2,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":0,"gen_end":518,"gen_start":415,"node":3,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":0,"gen_end":600,"gen_start":518,"node":4,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":0,"gen_end":622,"gen_start":600,"node":0,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0},{"artifact":1,"gen_end":328,"gen_start":134,"node":6,"role":"declaration","source":0,"src_end":255,"src_start":115},{"artifact":1,"gen_end":637,"gen_start":328,"node":7,"role":"declaration","source":0,"src_end":487,"src_start":257},{"artifact":1,"gen_end":886,"gen_start":637,"node":8,"role":"declaration","source":0,"src_end":671,"src_start":489},{"artifact":1,"gen_end":1078,"gen_start":886,"node":9,"role":"declaration","source":0,"src_end":825,"src_start":673},{"artifact":1,"gen_end":1093,"gen_start":1078,"node":5,"role":"declaration","source":0,"src_end":861,"src_start":0}],"module":"Syntax","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-latex-module"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"}],"semantic_id":"d478905735ed8adb7e0e1e617ced36dbb99b24d527400467981dfe38faea5841","source_id":"2f0ffdf34707ae74d9ea7bde2e298a2515e325f54a1de20fa2301e60a4e6656a","sources":[{"id":0,"kind":"file","path":"src/Syntax.lex.tex","sha256":"4d2d6d5cc65ee405c5b0fe2732babae4d496f16a4e054ac334d2abfa69152dd0"}],"spec":"lexlean/source-map/1"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.lean b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.lean similarity index 100% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.lean rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.process.json new file mode 100644 index 000000000..b8e1531a7 --- /dev/null +++ b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.lean b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.lean similarity index 100% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Laws.lean rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.process.json new file mode 100644 index 000000000..17201a665 --- /dev/null +++ b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.lean b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.lean similarity index 100% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.lean rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.process.json new file mode 100644 index 000000000..106025825 --- /dev/null +++ b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.lean b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.lean similarity index 100% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.lean rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.process.json similarity index 90% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.process.json rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.process.json index 7eeaeb6e9..9f2259c2e 100644 --- a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.process.json +++ b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Recursion.Main.countdown' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.countdown_nine' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.exprSize' does not depend on any axioms\n'Recursion.Main.expression_size' does not depend on any axioms\n'Recursion.Main.foldExpr' does not depend on any axioms\n'Recursion.Main.foldStatement' does not depend on any axioms\n'Recursion.Main.foldStatements' does not depend on any axioms\n'Recursion.Main.folding_sample' does not depend on any axioms\n'Recursion.Main.forestSize' does not depend on any axioms\n'Recursion.Main.isEven' does not depend on any axioms\n'Recursion.Main.isOdd' does not depend on any axioms\n'Recursion.Main.ping' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.ping_seven' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.ping_to_pong' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.pong' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.pong_to_ping' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune_plus' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune_result' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_literal' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_plus' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_weight' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce_twenty_three' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.roseSize' does not depend on any axioms\n'Recursion.Main.rose_size' does not depend on any axioms\n'Recursion.Main.search' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.search_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.search_first' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.statementSize' does not depend on any axioms\n'Recursion.Main.statementsSize' does not depend on any axioms\n'Recursion.Main.ten_is_even' does not depend on any axioms\n'Recursion.Main.weight' does not depend on any axioms\n","stdout_sha256":"f0c4e41ed308143236fb35a4287b2e6cf4fcc374313d2db6925bf81cee735602","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Recursion.Main.countdown' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.countdown_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.countdown_nine' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.exprSize' does not depend on any axioms\n'Recursion.Main.expression_size' does not depend on any axioms\n'Recursion.Main.foldExpr' does not depend on any axioms\n'Recursion.Main.foldStatement' does not depend on any axioms\n'Recursion.Main.foldStatements' does not depend on any axioms\n'Recursion.Main.folding_sample' does not depend on any axioms\n'Recursion.Main.forestSize' does not depend on any axioms\n'Recursion.Main.isEven' does not depend on any axioms\n'Recursion.Main.isOdd' does not depend on any axioms\n'Recursion.Main.ping' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.ping_seven' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.ping_to_pong' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.pong' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.pong_to_ping' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune_plus' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.prune_result' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_literal' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_plus' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reassociate_weight' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.reduce_twenty_three' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.roseSize' does not depend on any axioms\n'Recursion.Main.rose_size' does not depend on any axioms\n'Recursion.Main.search' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.search_decreases' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.search_first' depends on axioms: [propext, Quot.sound]\n'Recursion.Main.statementSize' does not depend on any axioms\n'Recursion.Main.statementsSize' does not depend on any axioms\n'Recursion.Main.ten_is_even' does not depend on any axioms\n'Recursion.Main.weight' does not depend on any axioms\n","stdout_sha256":"f0c4e41ed308143236fb35a4287b2e6cf4fcc374313d2db6925bf81cee735602","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.lean b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.lean similarity index 100% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.lean rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.lean diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.process.json similarity index 61% rename from examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.process.json rename to examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.process.json index 3ae6ba1ad..507122cd8 100644 --- a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.process.json +++ b/examples/recursion/expected/verify/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.Recursion.Syntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Recursion.Syntax.Expr' does not depend on any axioms\n'Recursion.Syntax.Rose' does not depend on any axioms\n'Recursion.Syntax.Stmt' does not depend on any axioms\n'Recursion.Syntax.Term' does not depend on any axioms\n","stdout_sha256":"59c34faf221d3617692f5b38aa55c8d27450f65f8daa542168e23f3a02fad8f8","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ad478905735ed8adb7e0e1e617ced36db.Recursion.Syntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'Recursion.Syntax.Expr' does not depend on any axioms\n'Recursion.Syntax.Rose' does not depend on any axioms\n'Recursion.Syntax.Stmt' does not depend on any axioms\n'Recursion.Syntax.Term' does not depend on any axioms\n","stdout_sha256":"59c34faf221d3617692f5b38aa55c8d27450f65f8daa542168e23f3a02fad8f8","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.process.json deleted file mode 100644 index fefa765d3..000000000 --- a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.process.json b/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.process.json deleted file mode 100644 index 2689d391b..000000000 --- a/examples/recursion/expected/verify/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.process.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Afca4cff7cd9d7d680879d32a7e810d91.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/examples/recursion/expected/verify/probe/LexLeanProbe.Pfca4cff7cd9d7d680879d32a7e810d91.lean b/examples/recursion/expected/verify/probe/LexLeanProbe.Pd478905735ed8adb7e0e1e617ced36db.lean similarity index 100% rename from examples/recursion/expected/verify/probe/LexLeanProbe.Pfca4cff7cd9d7d680879d32a7e810d91.lean rename to examples/recursion/expected/verify/probe/LexLeanProbe.Pd478905735ed8adb7e0e1e617ced36db.lean diff --git a/examples/recursion/expected/verify/probe/process.json b/examples/recursion/expected/verify/probe/process.json index a643b8000..b1b7a2a4e 100644 --- a/examples/recursion/expected/verify/probe/process.json +++ b/examples/recursion/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pfca4cff7cd9d7d680879d32a7e810d91.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pfca4cff7cd9d7d680879d32a7e810d91","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pd478905735ed8adb7e0e1e617ced36db.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pd478905735ed8adb7e0e1e617ced36db","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/recursion/lexlean.lock b/examples/recursion/lexlean.lock index 0d99d2501..0f2208fb3 100644 --- a/examples/recursion/lexlean.lock +++ b/examples/recursion/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b8201330ef8609d8f53e24e2fa367697675b98d69ba844d6a75adffe84a88319" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursive-data/expected/build/manifest.json b/examples/recursive-data/expected/build/manifest.json index c00b24e28..b91d11e82 100644 --- a/examples/recursive-data/expected/build/manifest.json +++ b/examples/recursive-data/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"eb4dd30a97e75979a8032532bdb5b65c812f19188cd012c9aee0e4e996244441","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"0816c513dbc26209c0d3b2daffa0d8ee8aa9b3f618a09fa41afcadea63f53317"},{"byte_length":649,"kind":"project-config","path":"lexlean.toml","sha256":"80db82abec1dcb95e34e18635f4b202b28e8653cf44949647692cd16549adf5e"},{"byte_length":3465,"kind":"source","path":"src/Main.lex.tex","sha256":"b30ab3d9e9a24ce422d32f01d402437e2ca3777275093328e70cae556f5f1e2b"},{"byte_length":1569,"kind":"source","path":"src/Types.lex.tex","sha256":"9a5066adc4be3255299b80f0d5e548876ba12b325a8894c9ae09772c6b8c5d98"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"RecursiveData.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"RecursiveData.Types","module":"Types","source_path":"src/Types.lex.tex"}],"outputs":[{"byte_length":11452,"kind":"coverage","path":"coverage/RecursiveData/Main.coverage.json","sha256":"381b7f0711c441b2073817ad599aefaa5251512d2c0c15163d4589f226a8c216"},{"byte_length":8709,"kind":"coverage","path":"coverage/RecursiveData/Types.coverage.json","sha256":"53bf5e13d86e57408b56f4072fb836a09a48c3baa3920151c680dd10ce79c2aa"},{"byte_length":2994,"kind":"lean","path":"modules/RecursiveData/Main.lean","sha256":"5b2e0441117ee0aae63c7a6b77693aadda58593c18ec31406c537c67f1b0ef57"},{"byte_length":1060,"kind":"lean","path":"modules/RecursiveData/Types.lean","sha256":"d2b39360b50d9c45e42f266146ba0eb32220d1f5a98bdc51d28ce384a21d508e"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Types.closure.json","sha256":"340585fd2c4c6277fb7214262beee52046db9b165cb6290c4b160f1e4ddc118c"},{"byte_length":6160,"kind":"map","path":"maps/RecursiveData/Main.map.json","sha256":"dd635f79cee7df1f154c742528416f8debef5a321354ddf4c11433ea9eecd3f2"},{"byte_length":3571,"kind":"map","path":"maps/RecursiveData/Types.map.json","sha256":"6e83ed349ac6c275e17d84b591ebca36e64bfe96c350c1ee4b139d4c08608f12"},{"byte_length":5103,"kind":"tex","path":"modules/RecursiveData/Main.tex","sha256":"5b7381fbe633721cc513cd66a7b19d07138eb2fbad21b72f41b9a35917c4c5b9"},{"byte_length":2183,"kind":"tex","path":"modules/RecursiveData/Types.tex","sha256":"8ac0c2997937026e5b703458fc16cdef181c85aeb6f3d640a7ad89e4d4125736"}],"project":"recursive-data","selection":["Main","Types"],"semantic_id":"2c35ce90452a8eb92de5f1e3f4d239477d4a49c142aa5e130b45e5c073a84bbc","source_id":"a29a7cf6fb921623ad50bab99d796986a7c61a566498d459e2c735eaf790ac93","spec":"lexlean/build-manifest/1"} +{"build_id":"c771e297a3f40b7fed775dbf921fd2871fbfc783c632586bd17246da38d569e3","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"66d7f4e6fe32482bbb94801dc8b9a667d2824900674b3fe2ab56caa28380c994"},{"byte_length":649,"kind":"project-config","path":"lexlean.toml","sha256":"80db82abec1dcb95e34e18635f4b202b28e8653cf44949647692cd16549adf5e"},{"byte_length":3465,"kind":"source","path":"src/Main.lex.tex","sha256":"b30ab3d9e9a24ce422d32f01d402437e2ca3777275093328e70cae556f5f1e2b"},{"byte_length":1569,"kind":"source","path":"src/Types.lex.tex","sha256":"9a5066adc4be3255299b80f0d5e548876ba12b325a8894c9ae09772c6b8c5d98"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"RecursiveData.Main","module":"Main","source_path":"src/Main.lex.tex"},{"lean_module":"RecursiveData.Types","module":"Types","source_path":"src/Types.lex.tex"}],"outputs":[{"byte_length":11452,"kind":"coverage","path":"coverage/RecursiveData/Main.coverage.json","sha256":"381b7f0711c441b2073817ad599aefaa5251512d2c0c15163d4589f226a8c216"},{"byte_length":8709,"kind":"coverage","path":"coverage/RecursiveData/Types.coverage.json","sha256":"53bf5e13d86e57408b56f4072fb836a09a48c3baa3920151c680dd10ce79c2aa"},{"byte_length":2994,"kind":"lean","path":"modules/RecursiveData/Main.lean","sha256":"5b2e0441117ee0aae63c7a6b77693aadda58593c18ec31406c537c67f1b0ef57"},{"byte_length":1060,"kind":"lean","path":"modules/RecursiveData/Types.lean","sha256":"d2b39360b50d9c45e42f266146ba0eb32220d1f5a98bdc51d28ce384a21d508e"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":10603,"kind":"lexicon-closure","path":"lexicons/Types.closure.json","sha256":"340585fd2c4c6277fb7214262beee52046db9b165cb6290c4b160f1e4ddc118c"},{"byte_length":6160,"kind":"map","path":"maps/RecursiveData/Main.map.json","sha256":"04ea0bea73f4a2b4acbc05c155cbdccf4fd8f16d220ed7e69d1c0e51c88f94be"},{"byte_length":3571,"kind":"map","path":"maps/RecursiveData/Types.map.json","sha256":"ce701a6b91de053d7329a18cf1ae6c104f001dc02157e26c4734da3d37fda743"},{"byte_length":5103,"kind":"tex","path":"modules/RecursiveData/Main.tex","sha256":"5b7381fbe633721cc513cd66a7b19d07138eb2fbad21b72f41b9a35917c4c5b9"},{"byte_length":2183,"kind":"tex","path":"modules/RecursiveData/Types.tex","sha256":"8ac0c2997937026e5b703458fc16cdef181c85aeb6f3d640a7ad89e4d4125736"}],"project":"recursive-data","selection":["Main","Types"],"semantic_id":"6a8a70f31374da43548df5adbfe486007a9f58fbf8eb4ac9fbfca129bdcd3584","source_id":"ff1d26eb8dffe0a57d91999992fea9dda2753754a6e9e4e03af56805999996c7","spec":"lexlean/build-manifest/1"} diff --git a/examples/recursive-data/expected/build/maps/RecursiveData/Main.map.json b/examples/recursive-data/expected/build/maps/RecursiveData/Main.map.json index 4cbf26da1..0b1ce6ffa 100644 --- a/examples/recursive-data/expected/build/maps/RecursiveData/Main.map.json +++ b/examples/recursive-data/expected/build/maps/RecursiveData/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/RecursiveData/Main.lean"},{"id":1,"kind":"tex","path":"modules/RecursiveData/Main.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":0,"gen_end":447,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":385,"src_start":134},{"artifact":0,"gen_end":744,"gen_start":447,"node":2,"role":"declaration","source":0,"src_end":700,"src_start":387},{"artifact":0,"gen_end":979,"gen_start":744,"node":3,"role":"declaration","source":0,"src_end":944,"src_start":702},{"artifact":0,"gen_end":1057,"gen_start":979,"node":4,"role":"declaration","source":0,"src_end":1062,"src_start":946},{"artifact":0,"gen_end":1344,"gen_start":1057,"node":5,"role":"declaration","source":0,"src_end":1552,"src_start":1064},{"artifact":0,"gen_end":1492,"gen_start":1344,"node":6,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":0,"gen_end":1632,"gen_start":1492,"node":7,"role":"declaration","source":0,"src_end":1868,"src_start":1709},{"artifact":0,"gen_end":1874,"gen_start":1632,"node":8,"role":"declaration","source":0,"src_end":2121,"src_start":1870},{"artifact":0,"gen_end":2140,"gen_start":1874,"node":9,"role":"declaration","source":0,"src_end":2378,"src_start":2123},{"artifact":0,"gen_end":2359,"gen_start":2140,"node":10,"role":"declaration","source":0,"src_end":2587,"src_start":2380},{"artifact":0,"gen_end":2465,"gen_start":2359,"node":11,"role":"declaration","source":0,"src_end":2745,"src_start":2589},{"artifact":0,"gen_end":2567,"gen_start":2465,"node":12,"role":"declaration","source":0,"src_end":2873,"src_start":2747},{"artifact":0,"gen_end":2691,"gen_start":2567,"node":13,"role":"declaration","source":0,"src_end":3016,"src_start":2875},{"artifact":0,"gen_end":2768,"gen_start":2691,"node":14,"role":"declaration","source":0,"src_end":3143,"src_start":3018},{"artifact":0,"gen_end":2830,"gen_start":2768,"node":15,"role":"declaration","source":0,"src_end":3241,"src_start":3145},{"artifact":0,"gen_end":2970,"gen_start":2830,"node":16,"role":"declaration","source":0,"src_end":3429,"src_start":3243},{"artifact":0,"gen_end":2994,"gen_start":2970,"node":0,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":1,"gen_end":543,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":385,"src_start":134},{"artifact":1,"gen_end":1036,"gen_start":543,"node":19,"role":"declaration","source":0,"src_end":700,"src_start":387},{"artifact":1,"gen_end":1417,"gen_start":1036,"node":20,"role":"declaration","source":0,"src_end":944,"src_start":702},{"artifact":1,"gen_end":1603,"gen_start":1417,"node":21,"role":"declaration","source":0,"src_end":1062,"src_start":946},{"artifact":1,"gen_end":1880,"gen_start":1603,"node":22,"role":"declaration","source":0,"src_end":1552,"src_start":1064},{"artifact":1,"gen_end":2211,"gen_start":1880,"node":23,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":1,"gen_end":2461,"gen_start":2211,"node":24,"role":"declaration","source":0,"src_end":1868,"src_start":1709},{"artifact":1,"gen_end":2890,"gen_start":2461,"node":25,"role":"declaration","source":0,"src_end":2121,"src_start":1870},{"artifact":1,"gen_end":3268,"gen_start":2890,"node":26,"role":"declaration","source":0,"src_end":2378,"src_start":2123},{"artifact":1,"gen_end":3670,"gen_start":3268,"node":27,"role":"declaration","source":0,"src_end":2587,"src_start":2380},{"artifact":1,"gen_end":3886,"gen_start":3670,"node":28,"role":"declaration","source":0,"src_end":2745,"src_start":2589},{"artifact":1,"gen_end":4170,"gen_start":3886,"node":29,"role":"declaration","source":0,"src_end":2873,"src_start":2747},{"artifact":1,"gen_end":4476,"gen_start":4170,"node":30,"role":"declaration","source":0,"src_end":3016,"src_start":2875},{"artifact":1,"gen_end":4664,"gen_start":4476,"node":31,"role":"declaration","source":0,"src_end":3143,"src_start":3018},{"artifact":1,"gen_end":4836,"gen_start":4664,"node":32,"role":"declaration","source":0,"src_end":3241,"src_start":3145},{"artifact":1,"gen_end":5088,"gen_start":4836,"node":33,"role":"declaration","source":0,"src_end":3429,"src_start":3243},{"artifact":1,"gen_end":5103,"gen_start":5088,"node":17,"role":"declaration","source":0,"src_end":3465,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"2c35ce90452a8eb92de5f1e3f4d239477d4a49c142aa5e130b45e5c073a84bbc","source_id":"a29a7cf6fb921623ad50bab99d796986a7c61a566498d459e2c735eaf790ac93","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"b30ab3d9e9a24ce422d32f01d402437e2ca3777275093328e70cae556f5f1e2b"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/RecursiveData/Main.lean"},{"id":1,"kind":"tex","path":"modules/RecursiveData/Main.tex"}],"mappings":[{"artifact":0,"gen_end":235,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":0,"gen_end":447,"gen_start":235,"node":1,"role":"declaration","source":0,"src_end":385,"src_start":134},{"artifact":0,"gen_end":744,"gen_start":447,"node":2,"role":"declaration","source":0,"src_end":700,"src_start":387},{"artifact":0,"gen_end":979,"gen_start":744,"node":3,"role":"declaration","source":0,"src_end":944,"src_start":702},{"artifact":0,"gen_end":1057,"gen_start":979,"node":4,"role":"declaration","source":0,"src_end":1062,"src_start":946},{"artifact":0,"gen_end":1344,"gen_start":1057,"node":5,"role":"declaration","source":0,"src_end":1552,"src_start":1064},{"artifact":0,"gen_end":1492,"gen_start":1344,"node":6,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":0,"gen_end":1632,"gen_start":1492,"node":7,"role":"declaration","source":0,"src_end":1868,"src_start":1709},{"artifact":0,"gen_end":1874,"gen_start":1632,"node":8,"role":"declaration","source":0,"src_end":2121,"src_start":1870},{"artifact":0,"gen_end":2140,"gen_start":1874,"node":9,"role":"declaration","source":0,"src_end":2378,"src_start":2123},{"artifact":0,"gen_end":2359,"gen_start":2140,"node":10,"role":"declaration","source":0,"src_end":2587,"src_start":2380},{"artifact":0,"gen_end":2465,"gen_start":2359,"node":11,"role":"declaration","source":0,"src_end":2745,"src_start":2589},{"artifact":0,"gen_end":2567,"gen_start":2465,"node":12,"role":"declaration","source":0,"src_end":2873,"src_start":2747},{"artifact":0,"gen_end":2691,"gen_start":2567,"node":13,"role":"declaration","source":0,"src_end":3016,"src_start":2875},{"artifact":0,"gen_end":2768,"gen_start":2691,"node":14,"role":"declaration","source":0,"src_end":3143,"src_start":3018},{"artifact":0,"gen_end":2830,"gen_start":2768,"node":15,"role":"declaration","source":0,"src_end":3241,"src_start":3145},{"artifact":0,"gen_end":2970,"gen_start":2830,"node":16,"role":"declaration","source":0,"src_end":3429,"src_start":3243},{"artifact":0,"gen_end":2994,"gen_start":2970,"node":0,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":17,"role":"declaration","source":0,"src_end":3465,"src_start":0},{"artifact":1,"gen_end":543,"gen_start":134,"node":18,"role":"declaration","source":0,"src_end":385,"src_start":134},{"artifact":1,"gen_end":1036,"gen_start":543,"node":19,"role":"declaration","source":0,"src_end":700,"src_start":387},{"artifact":1,"gen_end":1417,"gen_start":1036,"node":20,"role":"declaration","source":0,"src_end":944,"src_start":702},{"artifact":1,"gen_end":1603,"gen_start":1417,"node":21,"role":"declaration","source":0,"src_end":1062,"src_start":946},{"artifact":1,"gen_end":1880,"gen_start":1603,"node":22,"role":"declaration","source":0,"src_end":1552,"src_start":1064},{"artifact":1,"gen_end":2211,"gen_start":1880,"node":23,"role":"declaration","source":0,"src_end":1707,"src_start":1554},{"artifact":1,"gen_end":2461,"gen_start":2211,"node":24,"role":"declaration","source":0,"src_end":1868,"src_start":1709},{"artifact":1,"gen_end":2890,"gen_start":2461,"node":25,"role":"declaration","source":0,"src_end":2121,"src_start":1870},{"artifact":1,"gen_end":3268,"gen_start":2890,"node":26,"role":"declaration","source":0,"src_end":2378,"src_start":2123},{"artifact":1,"gen_end":3670,"gen_start":3268,"node":27,"role":"declaration","source":0,"src_end":2587,"src_start":2380},{"artifact":1,"gen_end":3886,"gen_start":3670,"node":28,"role":"declaration","source":0,"src_end":2745,"src_start":2589},{"artifact":1,"gen_end":4170,"gen_start":3886,"node":29,"role":"declaration","source":0,"src_end":2873,"src_start":2747},{"artifact":1,"gen_end":4476,"gen_start":4170,"node":30,"role":"declaration","source":0,"src_end":3016,"src_start":2875},{"artifact":1,"gen_end":4664,"gen_start":4476,"node":31,"role":"declaration","source":0,"src_end":3143,"src_start":3018},{"artifact":1,"gen_end":4836,"gen_start":4664,"node":32,"role":"declaration","source":0,"src_end":3241,"src_start":3145},{"artifact":1,"gen_end":5088,"gen_start":4836,"node":33,"role":"declaration","source":0,"src_end":3429,"src_start":3243},{"artifact":1,"gen_end":5103,"gen_start":5088,"node":17,"role":"declaration","source":0,"src_end":3465,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-latex-module"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"}],"semantic_id":"6a8a70f31374da43548df5adbfe486007a9f58fbf8eb4ac9fbfca129bdcd3584","source_id":"ff1d26eb8dffe0a57d91999992fea9dda2753754a6e9e4e03af56805999996c7","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"b30ab3d9e9a24ce422d32f01d402437e2ca3777275093328e70cae556f5f1e2b"}],"spec":"lexlean/source-map/1"} diff --git a/examples/recursive-data/expected/build/maps/RecursiveData/Types.map.json b/examples/recursive-data/expected/build/maps/RecursiveData/Types.map.json index d29024b50..3a735af36 100644 --- a/examples/recursive-data/expected/build/maps/RecursiveData/Types.map.json +++ b/examples/recursive-data/expected/build/maps/RecursiveData/Types.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/RecursiveData/Types.lean"},{"id":1,"kind":"tex","path":"modules/RecursiveData/Types.tex"}],"mappings":[{"artifact":0,"gen_end":202,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":0,"gen_end":310,"gen_start":202,"node":1,"role":"declaration","source":0,"src_end":299,"src_start":114},{"artifact":0,"gen_end":398,"gen_start":310,"node":2,"role":"declaration","source":0,"src_end":441,"src_start":301},{"artifact":0,"gen_end":526,"gen_start":398,"node":3,"role":"declaration","source":0,"src_end":673,"src_start":443},{"artifact":0,"gen_end":629,"gen_start":526,"node":4,"role":"declaration","source":0,"src_end":857,"src_start":675},{"artifact":0,"gen_end":721,"gen_start":629,"node":5,"role":"declaration","source":0,"src_end":1014,"src_start":859},{"artifact":0,"gen_end":830,"gen_start":721,"node":6,"role":"declaration","source":0,"src_end":1208,"src_start":1016},{"artifact":0,"gen_end":942,"gen_start":830,"node":7,"role":"declaration","source":0,"src_end":1381,"src_start":1210},{"artifact":0,"gen_end":1035,"gen_start":942,"node":8,"role":"declaration","source":0,"src_end":1533,"src_start":1383},{"artifact":0,"gen_end":1060,"gen_start":1035,"node":0,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":1,"gen_end":388,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":299,"src_start":114},{"artifact":1,"gen_end":582,"gen_start":388,"node":11,"role":"declaration","source":0,"src_end":441,"src_start":301},{"artifact":1,"gen_end":891,"gen_start":582,"node":12,"role":"declaration","source":0,"src_end":673,"src_start":443},{"artifact":1,"gen_end":1140,"gen_start":891,"node":13,"role":"declaration","source":0,"src_end":857,"src_start":675},{"artifact":1,"gen_end":1376,"gen_start":1140,"node":14,"role":"declaration","source":0,"src_end":1014,"src_start":859},{"artifact":1,"gen_end":1677,"gen_start":1376,"node":15,"role":"declaration","source":0,"src_end":1208,"src_start":1016},{"artifact":1,"gen_end":1930,"gen_start":1677,"node":16,"role":"declaration","source":0,"src_end":1381,"src_start":1210},{"artifact":1,"gen_end":2168,"gen_start":1930,"node":17,"role":"declaration","source":0,"src_end":1533,"src_start":1383},{"artifact":1,"gen_end":2183,"gen_start":2168,"node":9,"role":"declaration","source":0,"src_end":1569,"src_start":0}],"module":"Types","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"2c35ce90452a8eb92de5f1e3f4d239477d4a49c142aa5e130b45e5c073a84bbc","source_id":"a29a7cf6fb921623ad50bab99d796986a7c61a566498d459e2c735eaf790ac93","sources":[{"id":0,"kind":"file","path":"src/Types.lex.tex","sha256":"9a5066adc4be3255299b80f0d5e548876ba12b325a8894c9ae09772c6b8c5d98"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/RecursiveData/Types.lean"},{"id":1,"kind":"tex","path":"modules/RecursiveData/Types.tex"}],"mappings":[{"artifact":0,"gen_end":202,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":0,"gen_end":310,"gen_start":202,"node":1,"role":"declaration","source":0,"src_end":299,"src_start":114},{"artifact":0,"gen_end":398,"gen_start":310,"node":2,"role":"declaration","source":0,"src_end":441,"src_start":301},{"artifact":0,"gen_end":526,"gen_start":398,"node":3,"role":"declaration","source":0,"src_end":673,"src_start":443},{"artifact":0,"gen_end":629,"gen_start":526,"node":4,"role":"declaration","source":0,"src_end":857,"src_start":675},{"artifact":0,"gen_end":721,"gen_start":629,"node":5,"role":"declaration","source":0,"src_end":1014,"src_start":859},{"artifact":0,"gen_end":830,"gen_start":721,"node":6,"role":"declaration","source":0,"src_end":1208,"src_start":1016},{"artifact":0,"gen_end":942,"gen_start":830,"node":7,"role":"declaration","source":0,"src_end":1381,"src_start":1210},{"artifact":0,"gen_end":1035,"gen_start":942,"node":8,"role":"declaration","source":0,"src_end":1533,"src_start":1383},{"artifact":0,"gen_end":1060,"gen_start":1035,"node":0,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":1569,"src_start":0},{"artifact":1,"gen_end":388,"gen_start":134,"node":10,"role":"declaration","source":0,"src_end":299,"src_start":114},{"artifact":1,"gen_end":582,"gen_start":388,"node":11,"role":"declaration","source":0,"src_end":441,"src_start":301},{"artifact":1,"gen_end":891,"gen_start":582,"node":12,"role":"declaration","source":0,"src_end":673,"src_start":443},{"artifact":1,"gen_end":1140,"gen_start":891,"node":13,"role":"declaration","source":0,"src_end":857,"src_start":675},{"artifact":1,"gen_end":1376,"gen_start":1140,"node":14,"role":"declaration","source":0,"src_end":1014,"src_start":859},{"artifact":1,"gen_end":1677,"gen_start":1376,"node":15,"role":"declaration","source":0,"src_end":1208,"src_start":1016},{"artifact":1,"gen_end":1930,"gen_start":1677,"node":16,"role":"declaration","source":0,"src_end":1381,"src_start":1210},{"artifact":1,"gen_end":2168,"gen_start":1930,"node":17,"role":"declaration","source":0,"src_end":1533,"src_start":1383},{"artifact":1,"gen_end":2183,"gen_start":2168,"node":9,"role":"declaration","source":0,"src_end":1569,"src_start":0}],"module":"Types","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-latex-module"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"}],"semantic_id":"6a8a70f31374da43548df5adbfe486007a9f58fbf8eb4ac9fbfca129bdcd3584","source_id":"ff1d26eb8dffe0a57d91999992fea9dda2753754a6e9e4e03af56805999996c7","sources":[{"id":0,"kind":"file","path":"src/Types.lex.tex","sha256":"9a5066adc4be3255299b80f0d5e548876ba12b325a8894c9ae09772c6b8c5d98"}],"spec":"lexlean/source-map/1"} diff --git a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.lean b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.lean similarity index 100% rename from examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.lean rename to examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.lean diff --git a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.process.json b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.process.json similarity index 82% rename from examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.process.json rename to examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.process.json index d6d2b53ad..527017642 100644 --- a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.process.json +++ b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'RecursiveData.Main.block_is_not_literal' does not depend on any axioms\n'RecursiveData.Main.isLiteral' does not depend on any axioms\n'RecursiveData.Main.located_row' does not depend on any axioms\n'RecursiveData.Main.mirror' does not depend on any axioms\n'RecursiveData.Main.mirror_involutive' depends on axioms: [propext]\n'RecursiveData.Main.outcomeOrZero' does not depend on any axioms\n'RecursiveData.Main.roseLabel' does not depend on any axioms\n'RecursiveData.Main.rose_label' does not depend on any axioms\n'RecursiveData.Main.sampleTree' does not depend on any axioms\n'RecursiveData.Main.sample_tree_size' does not depend on any axioms\n'RecursiveData.Main.success_value' does not depend on any axioms\n'RecursiveData.Main.sumPair' does not depend on any axioms\n'RecursiveData.Main.sum_pair' does not depend on any axioms\n'RecursiveData.Main.swap' does not depend on any axioms\n'RecursiveData.Main.swap_twice_first' does not depend on any axioms\n'RecursiveData.Main.treeSize' does not depend on any axioms\n","stdout_sha256":"3b07c25caeee31d0f08e31121ae52eadc6a742879b13dfe318cc5f6d24387205","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'RecursiveData.Main.block_is_not_literal' does not depend on any axioms\n'RecursiveData.Main.isLiteral' does not depend on any axioms\n'RecursiveData.Main.located_row' does not depend on any axioms\n'RecursiveData.Main.mirror' does not depend on any axioms\n'RecursiveData.Main.mirror_involutive' depends on axioms: [propext]\n'RecursiveData.Main.outcomeOrZero' does not depend on any axioms\n'RecursiveData.Main.roseLabel' does not depend on any axioms\n'RecursiveData.Main.rose_label' does not depend on any axioms\n'RecursiveData.Main.sampleTree' does not depend on any axioms\n'RecursiveData.Main.sample_tree_size' does not depend on any axioms\n'RecursiveData.Main.success_value' does not depend on any axioms\n'RecursiveData.Main.sumPair' does not depend on any axioms\n'RecursiveData.Main.sum_pair' does not depend on any axioms\n'RecursiveData.Main.swap' does not depend on any axioms\n'RecursiveData.Main.swap_twice_first' does not depend on any axioms\n'RecursiveData.Main.treeSize' does not depend on any axioms\n","stdout_sha256":"3b07c25caeee31d0f08e31121ae52eadc6a742879b13dfe318cc5f6d24387205","tool":"lean"} diff --git a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.lean b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.lean similarity index 100% rename from examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.lean rename to examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.lean diff --git a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.process.json b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.process.json similarity index 72% rename from examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.process.json rename to examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.process.json index 7bf95729a..922405163 100644 --- a/examples/recursive-data/expected/verify/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.process.json +++ b/examples/recursive-data/expected/verify/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A2c35ce90452a8eb92de5f1e3f4d23947.RecursiveData.Types","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'RecursiveData.Types.Branches' does not depend on any axioms\n'RecursiveData.Types.Expr' does not depend on any axioms\n'RecursiveData.Types.Located' does not depend on any axioms\n'RecursiveData.Types.Node' does not depend on any axioms\n'RecursiveData.Types.Outcome' does not depend on any axioms\n'RecursiveData.Types.Rose' does not depend on any axioms\n'RecursiveData.Types.Stmt' does not depend on any axioms\n'RecursiveData.Types.Tree' does not depend on any axioms\n","stdout_sha256":"0b199ad5cc4dded808f275b6dadb975abd7a0fb028eaeb1b25c6595c1af8f28b","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A6a8a70f31374da43548df5adbfe48600.RecursiveData.Types","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'RecursiveData.Types.Branches' does not depend on any axioms\n'RecursiveData.Types.Expr' does not depend on any axioms\n'RecursiveData.Types.Located' does not depend on any axioms\n'RecursiveData.Types.Node' does not depend on any axioms\n'RecursiveData.Types.Outcome' does not depend on any axioms\n'RecursiveData.Types.Rose' does not depend on any axioms\n'RecursiveData.Types.Stmt' does not depend on any axioms\n'RecursiveData.Types.Tree' does not depend on any axioms\n","stdout_sha256":"0b199ad5cc4dded808f275b6dadb975abd7a0fb028eaeb1b25c6595c1af8f28b","tool":"lean"} diff --git a/examples/recursive-data/expected/verify/probe/LexLeanProbe.P2c35ce90452a8eb92de5f1e3f4d23947.lean b/examples/recursive-data/expected/verify/probe/LexLeanProbe.P6a8a70f31374da43548df5adbfe48600.lean similarity index 100% rename from examples/recursive-data/expected/verify/probe/LexLeanProbe.P2c35ce90452a8eb92de5f1e3f4d23947.lean rename to examples/recursive-data/expected/verify/probe/LexLeanProbe.P6a8a70f31374da43548df5adbfe48600.lean diff --git a/examples/recursive-data/expected/verify/probe/process.json b/examples/recursive-data/expected/verify/probe/process.json index e7b38aed1..d7ab78a74 100644 --- a/examples/recursive-data/expected/verify/probe/process.json +++ b/examples/recursive-data/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P2c35ce90452a8eb92de5f1e3f4d23947.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P2c35ce90452a8eb92de5f1e3f4d23947","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P6a8a70f31374da43548df5adbfe48600.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P6a8a70f31374da43548df5adbfe48600","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/examples/recursive-data/lexlean.lock b/examples/recursive-data/lexlean.lock index 6d8c47119..1522b955f 100644 --- a/examples/recursive-data/lexlean.lock +++ b/examples/recursive-data/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "80db82abec1dcb95e34e18635f4b202b28e8653cf44949647692cd16549adf5e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/stdlib/expected/build/manifest.json b/stdlib/expected/build/manifest.json index 778a9e880..9cddae075 100644 --- a/stdlib/expected/build/manifest.json +++ b/stdlib/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"df8fe88c3f08d7e203fc2060c3b0162c14fcf9dd390e2739776c0281c77cc12f","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"91d61637d04070d9f07908addffe7ae93d00d1be9ea69a000b7636ab569da158"},{"byte_length":638,"kind":"project-config","path":"lexlean.toml","sha256":"e7fcfa884a8d0dcabfa2292f1bca96a530b17e56a96f4f68ff7eac749ba2b0c4"},{"byte_length":8081,"kind":"source","path":"src/Text.lex.tex","sha256":"57c487328b200f710abcf7ca1e0daf1086d31c32f668fba6e7f5dc1a2e4a1eca"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanStd.Text","module":"Text","source_path":"src/Text.lex.tex"}],"outputs":[{"byte_length":11380,"kind":"coverage","path":"coverage/LexLeanStd/Text.coverage.json","sha256":"56012da65c0236693084aec3c621eb772b1716d1045e47584d272c1bad490fe7"},{"byte_length":7428,"kind":"lean","path":"modules/LexLeanStd/Text.lean","sha256":"aa728aceefa15f78b7431bed5a20e300f1a3e80ec3de8293481622aa150b2d8c"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Text.closure.json","sha256":"1ad76d0ba0c5e4c958f3593285ad434936f9745f4c422cdd592be86889c16500"},{"byte_length":6807,"kind":"map","path":"maps/LexLeanStd/Text.map.json","sha256":"1d941f329fd2685394ad83d2484920a9e3aaa21af88b6b75d6f2d407d7b87957"},{"byte_length":32401,"kind":"production-eligibility","path":"production/LexLeanStd/Text.eligibility.json","sha256":"4b54b63c69a2686e1642b74588d6f9cd880011b85fba5e63e44deaf4fb278631"},{"byte_length":13276,"kind":"tex","path":"modules/LexLeanStd/Text.tex","sha256":"612cb8192fa44088c7fd3b13e8d654e5388b08d3159ee15c183c42b02c7cdc96"}],"project":"stdlib","selection":["Text"],"semantic_id":"5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee","source_id":"14354f2c3524a80a10b7c1338779f4f79e6d021dfb76b0ae62d9b45e4f9953f6","spec":"lexlean/build-manifest/1"} +{"build_id":"3dd442906f5d082b4857220a3e414510146f50b559d39a7dc00e3bd175137230","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"f93d180b4ee7a28b214e7ec14d944b2a9f726829ed2b2d6c8151a150bc2b65fb"},{"byte_length":638,"kind":"project-config","path":"lexlean.toml","sha256":"e7fcfa884a8d0dcabfa2292f1bca96a530b17e56a96f4f68ff7eac749ba2b0c4"},{"byte_length":8081,"kind":"source","path":"src/Text.lex.tex","sha256":"57c487328b200f710abcf7ca1e0daf1086d31c32f668fba6e7f5dc1a2e4a1eca"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanStd.Text","module":"Text","source_path":"src/Text.lex.tex"}],"outputs":[{"byte_length":11380,"kind":"coverage","path":"coverage/LexLeanStd/Text.coverage.json","sha256":"56012da65c0236693084aec3c621eb772b1716d1045e47584d272c1bad490fe7"},{"byte_length":7428,"kind":"lean","path":"modules/LexLeanStd/Text.lean","sha256":"aa728aceefa15f78b7431bed5a20e300f1a3e80ec3de8293481622aa150b2d8c"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Text.closure.json","sha256":"1ad76d0ba0c5e4c958f3593285ad434936f9745f4c422cdd592be86889c16500"},{"byte_length":6807,"kind":"map","path":"maps/LexLeanStd/Text.map.json","sha256":"035a06d48d355126facebaa67ff8f658dffc38a0de945f867ecb25d026bc0d9e"},{"byte_length":32401,"kind":"production-eligibility","path":"production/LexLeanStd/Text.eligibility.json","sha256":"4b54b63c69a2686e1642b74588d6f9cd880011b85fba5e63e44deaf4fb278631"},{"byte_length":13276,"kind":"tex","path":"modules/LexLeanStd/Text.tex","sha256":"612cb8192fa44088c7fd3b13e8d654e5388b08d3159ee15c183c42b02c7cdc96"}],"project":"stdlib","selection":["Text"],"semantic_id":"f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1","source_id":"9ff8eb447d5ddb42a8de0d84f3b266107db99d6641e3944452e0b9091cdbb357","spec":"lexlean/build-manifest/1"} diff --git a/stdlib/expected/build/maps/LexLeanStd/Text.map.json b/stdlib/expected/build/maps/LexLeanStd/Text.map.json index 7b1356df1..1a14ac74b 100644 --- a/stdlib/expected/build/maps/LexLeanStd/Text.map.json +++ b/stdlib/expected/build/maps/LexLeanStd/Text.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanStd/Text.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanStd/Text.tex"}],"mappings":[{"artifact":0,"gen_end":277,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":0,"gen_end":611,"gen_start":277,"node":1,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":0,"gen_end":760,"gen_start":611,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":0,"gen_end":940,"gen_start":760,"node":3,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":0,"gen_end":1181,"gen_start":940,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":0,"gen_end":1482,"gen_start":1181,"node":5,"role":"declaration","source":0,"src_end":1433,"src_start":1087},{"artifact":0,"gen_end":1948,"gen_start":1482,"node":6,"role":"declaration","source":0,"src_end":1924,"src_start":1435},{"artifact":0,"gen_end":2384,"gen_start":1948,"node":7,"role":"declaration","source":0,"src_end":2353,"src_start":1926},{"artifact":0,"gen_end":2696,"gen_start":2384,"node":8,"role":"declaration","source":0,"src_end":2718,"src_start":2355},{"artifact":0,"gen_end":2932,"gen_start":2696,"node":9,"role":"declaration","source":0,"src_end":3046,"src_start":2720},{"artifact":0,"gen_end":3177,"gen_start":2932,"node":10,"role":"declaration","source":0,"src_end":3293,"src_start":3048},{"artifact":0,"gen_end":3835,"gen_start":3177,"node":11,"role":"declaration","source":0,"src_end":4060,"src_start":3295},{"artifact":0,"gen_end":4452,"gen_start":3835,"node":12,"role":"declaration","source":0,"src_end":4720,"src_start":4062},{"artifact":0,"gen_end":4667,"gen_start":4452,"node":13,"role":"declaration","source":0,"src_end":4932,"src_start":4722},{"artifact":0,"gen_end":5315,"gen_start":4667,"node":14,"role":"declaration","source":0,"src_end":5690,"src_start":4934},{"artifact":0,"gen_end":5998,"gen_start":5315,"node":15,"role":"declaration","source":0,"src_end":6395,"src_start":5692},{"artifact":0,"gen_end":6505,"gen_start":5998,"node":16,"role":"declaration","source":0,"src_end":6993,"src_start":6397},{"artifact":0,"gen_end":6819,"gen_start":6505,"node":17,"role":"declaration","source":0,"src_end":7305,"src_start":6995},{"artifact":0,"gen_end":7407,"gen_start":6819,"node":18,"role":"declaration","source":0,"src_end":8045,"src_start":7307},{"artifact":0,"gen_end":7428,"gen_start":7407,"node":0,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":19,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":1,"gen_end":715,"gen_start":134,"node":20,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":1,"gen_end":1111,"gen_start":715,"node":21,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":1,"gen_end":1538,"gen_start":1111,"node":22,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":1,"gen_end":2027,"gen_start":1538,"node":23,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":1,"gen_end":2711,"gen_start":2027,"node":24,"role":"declaration","source":0,"src_end":1433,"src_start":1087},{"artifact":1,"gen_end":3524,"gen_start":2711,"node":25,"role":"declaration","source":0,"src_end":1924,"src_start":1435},{"artifact":1,"gen_end":4331,"gen_start":3524,"node":26,"role":"declaration","source":0,"src_end":2353,"src_start":1926},{"artifact":1,"gen_end":5009,"gen_start":4331,"node":27,"role":"declaration","source":0,"src_end":2718,"src_start":2355},{"artifact":1,"gen_end":5649,"gen_start":5009,"node":28,"role":"declaration","source":0,"src_end":3046,"src_start":2720},{"artifact":1,"gen_end":6222,"gen_start":5649,"node":29,"role":"declaration","source":0,"src_end":3293,"src_start":3048},{"artifact":1,"gen_end":7127,"gen_start":6222,"node":30,"role":"declaration","source":0,"src_end":4060,"src_start":3295},{"artifact":1,"gen_end":8201,"gen_start":7127,"node":31,"role":"declaration","source":0,"src_end":4720,"src_start":4062},{"artifact":1,"gen_end":8664,"gen_start":8201,"node":32,"role":"declaration","source":0,"src_end":4932,"src_start":4722},{"artifact":1,"gen_end":9559,"gen_start":8664,"node":33,"role":"declaration","source":0,"src_end":5690,"src_start":4934},{"artifact":1,"gen_end":10688,"gen_start":9559,"node":34,"role":"declaration","source":0,"src_end":6395,"src_start":5692},{"artifact":1,"gen_end":11642,"gen_start":10688,"node":35,"role":"declaration","source":0,"src_end":6993,"src_start":6397},{"artifact":1,"gen_end":12203,"gen_start":11642,"node":36,"role":"declaration","source":0,"src_end":7305,"src_start":6995},{"artifact":1,"gen_end":13261,"gen_start":12203,"node":37,"role":"declaration","source":0,"src_end":8045,"src_start":7307},{"artifact":1,"gen_end":13276,"gen_start":13261,"node":19,"role":"declaration","source":0,"src_end":8081,"src_start":0}],"module":"Text","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-latex-module"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"}],"semantic_id":"5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee","source_id":"14354f2c3524a80a10b7c1338779f4f79e6d021dfb76b0ae62d9b45e4f9953f6","sources":[{"id":0,"kind":"file","path":"src/Text.lex.tex","sha256":"57c487328b200f710abcf7ca1e0daf1086d31c32f668fba6e7f5dc1a2e4a1eca"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanStd/Text.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanStd/Text.tex"}],"mappings":[{"artifact":0,"gen_end":277,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":0,"gen_end":611,"gen_start":277,"node":1,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":0,"gen_end":760,"gen_start":611,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":0,"gen_end":940,"gen_start":760,"node":3,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":0,"gen_end":1181,"gen_start":940,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":0,"gen_end":1482,"gen_start":1181,"node":5,"role":"declaration","source":0,"src_end":1433,"src_start":1087},{"artifact":0,"gen_end":1948,"gen_start":1482,"node":6,"role":"declaration","source":0,"src_end":1924,"src_start":1435},{"artifact":0,"gen_end":2384,"gen_start":1948,"node":7,"role":"declaration","source":0,"src_end":2353,"src_start":1926},{"artifact":0,"gen_end":2696,"gen_start":2384,"node":8,"role":"declaration","source":0,"src_end":2718,"src_start":2355},{"artifact":0,"gen_end":2932,"gen_start":2696,"node":9,"role":"declaration","source":0,"src_end":3046,"src_start":2720},{"artifact":0,"gen_end":3177,"gen_start":2932,"node":10,"role":"declaration","source":0,"src_end":3293,"src_start":3048},{"artifact":0,"gen_end":3835,"gen_start":3177,"node":11,"role":"declaration","source":0,"src_end":4060,"src_start":3295},{"artifact":0,"gen_end":4452,"gen_start":3835,"node":12,"role":"declaration","source":0,"src_end":4720,"src_start":4062},{"artifact":0,"gen_end":4667,"gen_start":4452,"node":13,"role":"declaration","source":0,"src_end":4932,"src_start":4722},{"artifact":0,"gen_end":5315,"gen_start":4667,"node":14,"role":"declaration","source":0,"src_end":5690,"src_start":4934},{"artifact":0,"gen_end":5998,"gen_start":5315,"node":15,"role":"declaration","source":0,"src_end":6395,"src_start":5692},{"artifact":0,"gen_end":6505,"gen_start":5998,"node":16,"role":"declaration","source":0,"src_end":6993,"src_start":6397},{"artifact":0,"gen_end":6819,"gen_start":6505,"node":17,"role":"declaration","source":0,"src_end":7305,"src_start":6995},{"artifact":0,"gen_end":7407,"gen_start":6819,"node":18,"role":"declaration","source":0,"src_end":8045,"src_start":7307},{"artifact":0,"gen_end":7428,"gen_start":7407,"node":0,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":19,"role":"declaration","source":0,"src_end":8081,"src_start":0},{"artifact":1,"gen_end":715,"gen_start":134,"node":20,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":1,"gen_end":1111,"gen_start":715,"node":21,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":1,"gen_end":1538,"gen_start":1111,"node":22,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":1,"gen_end":2027,"gen_start":1538,"node":23,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":1,"gen_end":2711,"gen_start":2027,"node":24,"role":"declaration","source":0,"src_end":1433,"src_start":1087},{"artifact":1,"gen_end":3524,"gen_start":2711,"node":25,"role":"declaration","source":0,"src_end":1924,"src_start":1435},{"artifact":1,"gen_end":4331,"gen_start":3524,"node":26,"role":"declaration","source":0,"src_end":2353,"src_start":1926},{"artifact":1,"gen_end":5009,"gen_start":4331,"node":27,"role":"declaration","source":0,"src_end":2718,"src_start":2355},{"artifact":1,"gen_end":5649,"gen_start":5009,"node":28,"role":"declaration","source":0,"src_end":3046,"src_start":2720},{"artifact":1,"gen_end":6222,"gen_start":5649,"node":29,"role":"declaration","source":0,"src_end":3293,"src_start":3048},{"artifact":1,"gen_end":7127,"gen_start":6222,"node":30,"role":"declaration","source":0,"src_end":4060,"src_start":3295},{"artifact":1,"gen_end":8201,"gen_start":7127,"node":31,"role":"declaration","source":0,"src_end":4720,"src_start":4062},{"artifact":1,"gen_end":8664,"gen_start":8201,"node":32,"role":"declaration","source":0,"src_end":4932,"src_start":4722},{"artifact":1,"gen_end":9559,"gen_start":8664,"node":33,"role":"declaration","source":0,"src_end":5690,"src_start":4934},{"artifact":1,"gen_end":10688,"gen_start":9559,"node":34,"role":"declaration","source":0,"src_end":6395,"src_start":5692},{"artifact":1,"gen_end":11642,"gen_start":10688,"node":35,"role":"declaration","source":0,"src_end":6993,"src_start":6397},{"artifact":1,"gen_end":12203,"gen_start":11642,"node":36,"role":"declaration","source":0,"src_end":7305,"src_start":6995},{"artifact":1,"gen_end":13261,"gen_start":12203,"node":37,"role":"declaration","source":0,"src_end":8045,"src_start":7307},{"artifact":1,"gen_end":13276,"gen_start":13261,"node":19,"role":"declaration","source":0,"src_end":8081,"src_start":0}],"module":"Text","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-latex-module"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"}],"semantic_id":"f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1","source_id":"9ff8eb447d5ddb42a8de0d84f3b266107db99d6641e3944452e0b9091cdbb357","sources":[{"id":0,"kind":"file","path":"src/Text.lex.tex","sha256":"57c487328b200f710abcf7ca1e0daf1086d31c32f668fba6e7f5dc1a2e4a1eca"}],"spec":"lexlean/source-map/1"} diff --git a/stdlib/lexlean.lock b/stdlib/lexlean.lock index de65617eb..4b1424628 100644 --- a/stdlib/lexlean.lock +++ b/stdlib/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "e7fcfa884a8d0dcabfa2292f1bca96a530b17e56a96f4f68ff7eac749ba2b0c4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-arity/project/lexlean.lock b/tests/negative/application-arity/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/application-arity/project/lexlean.lock +++ b/tests/negative/application-arity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-non-function/project/lexlean.lock b/tests/negative/application-non-function/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/application-non-function/project/lexlean.lock +++ b/tests/negative/application-non-function/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-bool-literal-name/project/lexlean.lock b/tests/negative/binder-bool-literal-name/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/binder-bool-literal-name/project/lexlean.lock +++ b/tests/negative/binder-bool-literal-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-capture/project/lexlean.lock b/tests/negative/binder-capture/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/binder-capture/project/lexlean.lock +++ b/tests/negative/binder-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock index b9fb33cfa..a421bd3b9 100644 --- a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock +++ b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "81ee2a9ef8c129bd8d1d2c5a002526675b1f2cbabb784a33bbb447892bd48c9f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-b-rejected/expected/command.json b/tests/negative/certificate-b-rejected/expected/command.json index 3b561be08..15c21fc42 100644 --- a/tests/negative/certificate-b-rejected/expected/command.json +++ b/tests/negative/certificate-b-rejected/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7015","help":[],"labels":[],"message":"certificate B: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore` was rejected in `fun2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.157 = ?m.157\nbut is expected to have type\n RustSemantics.itemFallible RustSyntax.Item.natSub = true\nin the application\n Corr.primF (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) Corr.opsNil rfl rfl) rfl rfl) ?m.147 rfl\n rfl rfl rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7015","help":[],"labels":[],"message":"certificate B: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore` was rejected in `fun2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.157 = ?m.157\nbut is expected to have type\n RustSemantics.itemFallible RustSyntax.Item.natSub = true\nin the application\n Corr.primF (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) Corr.opsNil rfl rfl) rfl rfl) ?m.147 rfl\n rfl rfl rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-b-rejected/expected/diagnostics.json b/tests/negative/certificate-b-rejected/expected/diagnostics.json index 1501ee0ef..6805e3ac9 100644 --- a/tests/negative/certificate-b-rejected/expected/diagnostics.json +++ b/tests/negative/certificate-b-rejected/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLV7015","help":[],"labels":[],"message":"certificate B: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2.RustCore` was rejected in `fun2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.157 = ?m.157\nbut is expected to have type\n RustSemantics.itemFallible RustSyntax.Item.natSub = true\nin the application\n Corr.primF (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) Corr.opsNil rfl rfl) rfl rfl) ?m.147 rfl\n rfl rfl rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLV7015","help":[],"labels":[],"message":"certificate B: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2.RustCore` was rejected in `fun2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.157 = ?m.157\nbut is expected to have type\n RustSemantics.itemFallible RustSyntax.Item.natSub = true\nin the application\n Corr.primF (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) Corr.opsNil rfl rfl) rfl rfl) ?m.147 rfl\n rfl rfl rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-b-rejected/project/lexlean.lock b/tests/negative/certificate-b-rejected/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-b-rejected/project/lexlean.lock +++ b/tests/negative/certificate-b-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-e-rejected/expected/command.json b/tests/negative/certificate-e-rejected/expected/command.json index 380dd7106..bd245f9b9 100644 --- a/tests/negative/certificate-e-rejected/expected/command.json +++ b/tests/negative/certificate-e-rejected/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-e-rejected/expected/diagnostics.json b/tests/negative/certificate-e-rejected/expected/diagnostics.json index c270396e1..deef6b393 100644 --- a/tests/negative/certificate-e-rejected/expected/diagnostics.json +++ b/tests/negative/certificate-e-rejected/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-e-rejected/project/lexlean.lock b/tests/negative/certificate-e-rejected/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-e-rejected/project/lexlean.lock +++ b/tests/negative/certificate-e-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-generation-limit/project/lexlean.lock b/tests/negative/certificate-generation-limit/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-generation-limit/project/lexlean.lock +++ b/tests/negative/certificate-generation-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-heartbeat-rejected/expected/command.json b/tests/negative/certificate-heartbeat-rejected/expected/command.json index 0432d2fa0..ce35ae3a0 100644 --- a/tests/negative/certificate-heartbeat-rejected/expected/command.json +++ b/tests/negative/certificate-heartbeat-rejected/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.C52af23b9c4ffcfaac904d5bd28c047b5.R0` was rejected in `__prog` of root `Production.Main.total`: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C52af23b9c4ffcfaac904d5bd28c047b5/R0.lean:25:30: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C52af23b9c4ffcfaac904d5bd28c047b5/R0.lean:28:33: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.C5a8aecb66d2051046750612dda1e97aa.R0` was rejected in `__prog` of root `Production.Main.total`: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C5a8aecb66d2051046750612dda1e97aa/R0.lean:25:30: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C5a8aecb66d2051046750612dda1e97aa/R0.lean:28:33: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-heartbeat-rejected/expected/diagnostics.json b/tests/negative/certificate-heartbeat-rejected/expected/diagnostics.json index 41e753f2a..87d635b62 100644 --- a/tests/negative/certificate-heartbeat-rejected/expected/diagnostics.json +++ b/tests/negative/certificate-heartbeat-rejected/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.C52af23b9c4ffcfaac904d5bd28c047b5.R0` was rejected in `__prog` of root `Production.Main.total`: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C52af23b9c4ffcfaac904d5bd28c047b5/R0.lean:25:30: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C52af23b9c4ffcfaac904d5bd28c047b5/R0.lean:28:33: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.C5a8aecb66d2051046750612dda1e97aa.R0` was rejected in `__prog` of root `Production.Main.total`: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C5a8aecb66d2051046750612dda1e97aa/R0.lean:25:30: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n\nNote: Use `set_option maxHeartbeats ` to set the limit.\n\nHint: Additional diagnostic information may be available using the `set_option diagnostics true` command.\n$STAGING/preserve-src/LexLeanPreserve/C5a8aecb66d2051046750612dda1e97aa/R0.lean:28:33: error: (deterministic) timeout at `isDefEq`, maximum number of heartbeats (1) has been reached\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock +++ b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-rejected/expected/command.json b/tests/negative/certificate-rejected/expected/command.json index ece60aa39..e658edb14 100644 --- a/tests/negative/certificate-rejected/expected/command.json +++ b/tests/negative/certificate-rejected/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2` was rejected in `__rel_2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n LexLeanPreservation.prim_natAdd number number\nhas type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natAdd\n [LexLeanTarget.TargetSyntax.Value.nat number, LexLeanTarget.TargetSyntax.Value.nat number]) =\n some\n (LexLeanPreservation.Rel ((number + number).blt 18446744073709551616)\n (LexLeanTarget.TargetSyntax.Value.nat (number + number)))\nbut is expected to have type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natSub","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2` was rejected in `__rel_2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n LexLeanPreservation.prim_natAdd number number\nhas type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natAdd\n [LexLeanTarget.TargetSyntax.Value.nat number, LexLeanTarget.TargetSyntax.Value.nat number]) =\n some\n (LexLeanPreservation.Rel ((number + number).blt 18446744073709551616)\n (LexLeanTarget.TargetSyntax.Value.nat (number + number)))\nbut is expected to have type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natSub","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-rejected/expected/diagnostics.json b/tests/negative/certificate-rejected/expected/diagnostics.json index 9406a3a6b..f70711acb 100644 --- a/tests/negative/certificate-rejected/expected/diagnostics.json +++ b/tests/negative/certificate-rejected/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.Cecf58505f4e2844618eff0bdc9a2ce9d.R2` was rejected in `__rel_2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n LexLeanPreservation.prim_natAdd number number\nhas type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natAdd\n [LexLeanTarget.TargetSyntax.Value.nat number, LexLeanTarget.TargetSyntax.Value.nat number]) =\n some\n (LexLeanPreservation.Rel ((number + number).blt 18446744073709551616)\n (LexLeanTarget.TargetSyntax.Value.nat (number + number)))\nbut is expected to have type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natSub","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLV7013","help":[],"labels":[],"message":"certificate A: `LexLeanPreserve.Cf5a58e441acc8b93ded11826c51cc7c8.R2` was rejected in `__rel_2` of root `Production.Main.quadruple`: error: Application type mismatch: The argument\n LexLeanPreservation.prim_natAdd number number\nhas type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natAdd\n [LexLeanTarget.TargetSyntax.Value.nat number, LexLeanTarget.TargetSyntax.Value.nat number]) =\n some\n (LexLeanPreservation.Rel ((number + number).blt 18446744073709551616)\n (LexLeanTarget.TargetSyntax.Value.nat (number + number)))\nbut is expected to have type\n LexLeanPreservation.obs\n (LexLeanTarget.TargetSemantics.primitive LexLeanTarget.TargetSyntax.Prim.natSub","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-rejected/project/lexlean.lock b/tests/negative/certificate-rejected/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-rejected/project/lexlean.lock +++ b/tests/negative/certificate-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-resource-exhausted/expected/command.json b/tests/negative/certificate-resource-exhausted/expected/command.json index 7efa5ae15..6f440e241 100644 --- a/tests/negative/certificate-resource-exhausted/expected/command.json +++ b/tests/negative/certificate-resource-exhausted/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"the pinned Lean exhausted a resource checking `LexLeanPreserve.C52af23b9c4ffcfaac904d5bd28c047b5.R0` (maximum number of heartbeats): the generated module is 66000 bytes, at least a quarter of max_file_bytes 131072, and is beyond what the machine checks","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":4,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"the pinned Lean exhausted a resource checking `LexLeanPreserve.C5a8aecb66d2051046750612dda1e97aa.R0` (maximum number of heartbeats): the generated module is 66000 bytes, at least a quarter of max_file_bytes 131072, and is beyond what the machine checks","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":4,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-resource-exhausted/expected/diagnostics.json b/tests/negative/certificate-resource-exhausted/expected/diagnostics.json index b21603713..8c9f4e6c6 100644 --- a/tests/negative/certificate-resource-exhausted/expected/diagnostics.json +++ b/tests/negative/certificate-resource-exhausted/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"the pinned Lean exhausted a resource checking `LexLeanPreserve.C52af23b9c4ffcfaac904d5bd28c047b5.R0` (maximum number of heartbeats): the generated module is 66000 bytes, at least a quarter of max_file_bytes 131072, and is beyond what the machine checks","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"the pinned Lean exhausted a resource checking `LexLeanPreserve.C5a8aecb66d2051046750612dda1e97aa.R0` (maximum number of heartbeats): the generated module is 66000 bytes, at least a quarter of max_file_bytes 131072, and is beyond what the machine checks","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-resource-exhausted/project/lexlean.lock b/tests/negative/certificate-resource-exhausted/project/lexlean.lock index 45728b159..e486d6424 100644 --- a/tests/negative/certificate-resource-exhausted/project/lexlean.lock +++ b/tests/negative/certificate-resource-exhausted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "743b4fe5ccb7b0dcae4d1ddf7fed292c41f3bd01521f10a3295978ac215364cd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-size-limit/project/lexlean.lock b/tests/negative/certificate-size-limit/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/certificate-size-limit/project/lexlean.lock +++ b/tests/negative/certificate-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificates-total-limit/project/lexlean.lock b/tests/negative/certificates-total-limit/project/lexlean.lock index 3ac5b219e..561ded858 100644 --- a/tests/negative/certificates-total-limit/project/lexlean.lock +++ b/tests/negative/certificates-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "19396dab32e876e6744d5feb41043ceae6961ae8b3e677fc770b3b09fcdbc8ad" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-duplicate-key/project/lexlean.lock b/tests/negative/collection-duplicate-key/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-duplicate-key/project/lexlean.lock +++ b/tests/negative/collection-duplicate-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock +++ b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-literal-limit/project/lexlean.lock b/tests/negative/collection-literal-limit/project/lexlean.lock index 2467821c0..9ee531197 100644 --- a/tests/negative/collection-literal-limit/project/lexlean.lock +++ b/tests/negative/collection-literal-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "86eb9da7c6c50be25511dfe1cbf99f5e0ac82b411c2ed9b5b4e6c94924af2253" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-noncanonical-key/project/lexlean.lock b/tests/negative/collection-noncanonical-key/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-noncanonical-key/project/lexlean.lock +++ b/tests/negative/collection-noncanonical-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-nonliteral-key/project/lexlean.lock b/tests/negative/collection-nonliteral-key/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-nonliteral-key/project/lexlean.lock +++ b/tests/negative/collection-nonliteral-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-out-of-range-key/project/lexlean.lock b/tests/negative/collection-out-of-range-key/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-out-of-range-key/project/lexlean.lock +++ b/tests/negative/collection-out-of-range-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unbounded-iteration/project/lexlean.lock b/tests/negative/collection-unbounded-iteration/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-unbounded-iteration/project/lexlean.lock +++ b/tests/negative/collection-unbounded-iteration/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unordered-key/project/lexlean.lock b/tests/negative/collection-unordered-key/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/collection-unordered-key/project/lexlean.lock +++ b/tests/negative/collection-unordered-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cross-version-glossary/project/lexlean.lock b/tests/negative/cross-version-glossary/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/cross-version-glossary/project/lexlean.lock +++ b/tests/negative/cross-version-glossary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/declaration-lean-name/project/lexlean.lock b/tests/negative/declaration-lean-name/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/declaration-lean-name/project/lexlean.lock +++ b/tests/negative/declaration-lean-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-report-limit/project/lexlean.lock b/tests/negative/eligibility-report-limit/project/lexlean.lock index 8e800fdfc..ff2519a77 100644 --- a/tests/negative/eligibility-report-limit/project/lexlean.lock +++ b/tests/negative/eligibility-report-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock index 8e800fdfc..ff2519a77 100644 --- a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock +++ b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-in-data/project/lexlean.lock b/tests/negative/escaping-closure-in-data/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/escaping-closure-in-data/project/lexlean.lock +++ b/tests/negative/escaping-closure-in-data/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-parameter/project/lexlean.lock b/tests/negative/escaping-closure-parameter/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/escaping-closure-parameter/project/lexlean.lock +++ b/tests/negative/escaping-closure-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-structure/project/lexlean.lock b/tests/negative/escaping-closure-structure/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/escaping-closure-structure/project/lexlean.lock +++ b/tests/negative/escaping-closure-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure/project/lexlean.lock b/tests/negative/escaping-closure/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/escaping-closure/project/lexlean.lock +++ b/tests/negative/escaping-closure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/executable-calls-formal/project/lexlean.lock b/tests/negative/executable-calls-formal/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/executable-calls-formal/project/lexlean.lock +++ b/tests/negative/executable-calls-formal/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-authority-drift/project/lexlean.lock b/tests/negative/extraction-authority-drift/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/extraction-authority-drift/project/lexlean.lock +++ b/tests/negative/extraction-authority-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-rejected/project/lexlean.lock b/tests/negative/extraction-rejected/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/extraction-rejected/project/lexlean.lock +++ b/tests/negative/extraction-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-uncompiled-external/project/lexlean.lock b/tests/negative/extraction-uncompiled-external/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/extraction-uncompiled-external/project/lexlean.lock +++ b/tests/negative/extraction-uncompiled-external/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-duplicate-edge/project/lexlean.lock b/tests/negative/graph-duplicate-edge/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/graph-duplicate-edge/project/lexlean.lock +++ b/tests/negative/graph-duplicate-edge/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-invalid-reference/project/lexlean.lock b/tests/negative/graph-invalid-reference/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/graph-invalid-reference/project/lexlean.lock +++ b/tests/negative/graph-invalid-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-extra/project/lexlean.lock b/tests/negative/lambda-capture-extra/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/lambda-capture-extra/project/lexlean.lock +++ b/tests/negative/lambda-capture-extra/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-missing/project/lexlean.lock b/tests/negative/lambda-capture-missing/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/lambda-capture-missing/project/lexlean.lock +++ b/tests/negative/lambda-capture-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-type-mismatch/project/lexlean.lock b/tests/negative/lambda-type-mismatch/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/lambda-type-mismatch/project/lexlean.lock +++ b/tests/negative/lambda-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock index d6bc854eb..0a10d7d0d 100644 --- a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock +++ b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/1" language = "1.2" -compiler_semantics = "961282f94afc09dbbe84cdae395d5b36b6d57c559e4e5ef73d6a1935cb104e90" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-size-limit/project/lexlean.lock b/tests/negative/lowering-size-limit/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/lowering-size-limit/project/lexlean.lock +++ b/tests/negative/lowering-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/member-generated-name/project/lexlean.lock b/tests/negative/member-generated-name/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/member-generated-name/project/lexlean.lock +++ b/tests/negative/member-generated-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-decode-budget/project/lexlean.lock b/tests/negative/model-artifact-decode-budget/project/lexlean.lock index 55d3dbf2b..ea9da4e4b 100644 --- a/tests/negative/model-artifact-decode-budget/project/lexlean.lock +++ b/tests/negative/model-artifact-decode-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "97224c1005c098cfb00c28986caa7733eb43fd183f038947ba92d676edede581" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock index 540f6c6f3..273dc5949 100644 --- a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock +++ b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "7407260b337f63f50bc003afdc8e09e578096041ae6365e5b1f39d0dc3d8e093" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-missing/project/lexlean.lock b/tests/negative/model-artifact-missing/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-missing/project/lexlean.lock +++ b/tests/negative/model-artifact-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-over-limit/project/lexlean.lock b/tests/negative/model-artifact-over-limit/project/lexlean.lock index 2f92c82fe..b9f06a398 100644 --- a/tests/negative/model-artifact-over-limit/project/lexlean.lock +++ b/tests/negative/model-artifact-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6b2d40a11356013ad4366b900361329faecae628242794cbc0d2ba8a54ff7d4c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock index a573a05b0..4424e0add 100644 --- a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock +++ b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "9f0dd9fc1743c1e5be95b546a6d77274f7fd5ffc95c0920b73cfe4e007b47fe0" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-role-violation/project/lexlean.lock b/tests/negative/model-artifact-role-violation/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-role-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-role-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-schema-violation/project/lexlean.lock b/tests/negative/model-artifact-schema-violation/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-schema-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-schema-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock index f772a676a..433508a49 100644 --- a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-symlink/project/lexlean.lock b/tests/negative/model-artifact-symlink/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-artifact-symlink/project/lexlean.lock +++ b/tests/negative/model-artifact-symlink/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-unconfigured/project/lexlean.lock b/tests/negative/model-artifact-unconfigured/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-artifact-unconfigured/project/lexlean.lock +++ b/tests/negative/model-artifact-unconfigured/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-check-without-validator/project/lexlean.lock b/tests/negative/model-check-without-validator/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-check-without-validator/project/lexlean.lock +++ b/tests/negative/model-check-without-validator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-forged-junction/project/lexlean.lock b/tests/negative/model-composition-forged-junction/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-composition-forged-junction/project/lexlean.lock +++ b/tests/negative/model-composition-forged-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-missing-junction/project/lexlean.lock b/tests/negative/model-composition-missing-junction/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-composition-missing-junction/project/lexlean.lock +++ b/tests/negative/model-composition-missing-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-type-mismatch/project/lexlean.lock b/tests/negative/model-composition-type-mismatch/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-composition-type-mismatch/project/lexlean.lock +++ b/tests/negative/model-composition-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock +++ b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-encoder-width-forged/project/lexlean.lock b/tests/negative/model-encoder-width-forged/project/lexlean.lock index f772a676a..433508a49 100644 --- a/tests/negative/model-encoder-width-forged/project/lexlean.lock +++ b/tests/negative/model-encoder-width-forged/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-false-evidence/project/lexlean.lock b/tests/negative/model-false-evidence/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-false-evidence/project/lexlean.lock +++ b/tests/negative/model-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-float-descriptor/project/lexlean.lock b/tests/negative/model-float-descriptor/project/lexlean.lock index b0fb84dc4..defbe78b3 100644 --- a/tests/negative/model-float-descriptor/project/lexlean.lock +++ b/tests/negative/model-float-descriptor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-foreign-evidence/project/lexlean.lock b/tests/negative/model-foreign-evidence/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-foreign-evidence/project/lexlean.lock +++ b/tests/negative/model-foreign-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-forged-evidence/project/lexlean.lock b/tests/negative/model-forged-evidence/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-forged-evidence/project/lexlean.lock +++ b/tests/negative/model-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-missing-entry/project/lexlean.lock b/tests/negative/model-missing-entry/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-missing-entry/project/lexlean.lock +++ b/tests/negative/model-missing-entry/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-opaque-member/project/lexlean.lock b/tests/negative/model-opaque-member/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-opaque-member/project/lexlean.lock +++ b/tests/negative/model-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-predicate-signature/project/lexlean.lock b/tests/negative/model-predicate-signature/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-predicate-signature/project/lexlean.lock +++ b/tests/negative/model-predicate-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-realization-bypass/project/lexlean.lock b/tests/negative/model-realization-bypass/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-realization-bypass/project/lexlean.lock +++ b/tests/negative/model-realization-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unregistered-claim/project/lexlean.lock b/tests/negative/model-unregistered-claim/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-unregistered-claim/project/lexlean.lock +++ b/tests/negative/model-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-boundary/project/lexlean.lock b/tests/negative/model-unvalidated-boundary/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-unvalidated-boundary/project/lexlean.lock +++ b/tests/negative/model-unvalidated-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock +++ b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-vacuous-claim/project/lexlean.lock b/tests/negative/model-vacuous-claim/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-vacuous-claim/project/lexlean.lock +++ b/tests/negative/model-vacuous-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-validator-unsound-statement/project/lexlean.lock b/tests/negative/model-validator-unsound-statement/project/lexlean.lock index 77f0e12cd..99b0a7a65 100644 --- a/tests/negative/model-validator-unsound-statement/project/lexlean.lock +++ b/tests/negative/model-validator-unsound-statement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-first/project/lexlean.lock b/tests/negative/module-name-dotted-first/project/lexlean.lock index d539fed4d..05e8b55c9 100644 --- a/tests/negative/module-name-dotted-first/project/lexlean.lock +++ b/tests/negative/module-name-dotted-first/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "95276aad5a2f8e56451e0155187ce36290918ff47f8b6a315a4f65c3bfef9e71" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-last/project/lexlean.lock b/tests/negative/module-name-dotted-last/project/lexlean.lock index e3292348c..d93419227 100644 --- a/tests/negative/module-name-dotted-last/project/lexlean.lock +++ b/tests/negative/module-name-dotted-last/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "931ec0afb0a76b983ac4c428c862444a84cf5503f5dd3674b7f95f86e20d955e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-lean-namespace/project/lexlean.lock b/tests/negative/module-name-lean-namespace/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/module-name-lean-namespace/project/lexlean.lock +++ b/tests/negative/module-name-lean-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-target-production/project/lexlean.lock b/tests/negative/module-prefix-target-production/project/lexlean.lock index fb75275ed..5e1f9c441 100644 --- a/tests/negative/module-prefix-target-production/project/lexlean.lock +++ b/tests/negative/module-prefix-target-production/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "d4ba5893c2a056d009d9df7131d82f1a6f3a560659e43ded292d44b5d050ee2b" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock +++ b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-label-shared/project/lexlean.lock b/tests/negative/mutual-label-shared/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/mutual-label-shared/project/lexlean.lock +++ b/tests/negative/mutual-label-shared/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-ambiguity/project/lexlean.lock b/tests/negative/polymorphic-ambiguity/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/polymorphic-ambiguity/project/lexlean.lock +++ b/tests/negative/polymorphic-ambiguity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-recursion/project/lexlean.lock b/tests/negative/polymorphic-recursion/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/polymorphic-recursion/project/lexlean.lock +++ b/tests/negative/polymorphic-recursion/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/preservation-drift/project/lexlean.lock b/tests/negative/preservation-drift/project/lexlean.lock index d4a5c808a..17bc4d068 100644 --- a/tests/negative/preservation-drift/project/lexlean.lock +++ b/tests/negative/preservation-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-effect-mismatch/project/lexlean.lock b/tests/negative/production-effect-mismatch/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-effect-mismatch/project/lexlean.lock +++ b/tests/negative/production-effect-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-formal-only-dependency/project/lexlean.lock b/tests/negative/production-formal-only-dependency/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-formal-only-dependency/project/lexlean.lock +++ b/tests/negative/production-formal-only-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-hidden-dependency/project/lexlean.lock b/tests/negative/production-hidden-dependency/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-hidden-dependency/project/lexlean.lock +++ b/tests/negative/production-hidden-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-higher-order-escape/project/lexlean.lock b/tests/negative/production-higher-order-escape/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-higher-order-escape/project/lexlean.lock +++ b/tests/negative/production-higher-order-escape/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-literal-width/project/lexlean.lock b/tests/negative/production-literal-width/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-literal-width/project/lexlean.lock +++ b/tests/negative/production-literal-width/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-named-type-boundary/project/lexlean.lock b/tests/negative/production-named-type-boundary/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-named-type-boundary/project/lexlean.lock +++ b/tests/negative/production-named-type-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-phantom-type-parameter/project/lexlean.lock b/tests/negative/production-phantom-type-parameter/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-phantom-type-parameter/project/lexlean.lock +++ b/tests/negative/production-phantom-type-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-polymorphic-root/project/lexlean.lock b/tests/negative/production-polymorphic-root/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-polymorphic-root/project/lexlean.lock +++ b/tests/negative/production-polymorphic-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-not-executable/project/lexlean.lock b/tests/negative/production-root-not-executable/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-root-not-executable/project/lexlean.lock +++ b/tests/negative/production-root-not-executable/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock +++ b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unbounded-type/project/lexlean.lock b/tests/negative/production-unbounded-type/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-unbounded-type/project/lexlean.lock +++ b/tests/negative/production-unbounded-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-universe-boundary/project/lexlean.lock b/tests/negative/production-universe-boundary/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-universe-boundary/project/lexlean.lock +++ b/tests/negative/production-universe-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unknown-target/project/lexlean.lock b/tests/negative/production-unknown-target/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/production-unknown-target/project/lexlean.lock +++ b/tests/negative/production-unknown-target/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-type/project/lexlean.lock b/tests/negative/reasoning-answer-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-answer-type/project/lexlean.lock +++ b/tests/negative/reasoning-answer-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-binder-reserved/project/lexlean.lock b/tests/negative/reasoning-binder-reserved/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-binder-reserved/project/lexlean.lock +++ b/tests/negative/reasoning-binder-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock +++ b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock +++ b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock +++ b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock index b10ab74a0..639d2edf0 100644 --- a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock +++ b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "32962ccccc0e0504497383fdd12cf9f1e761305e58c22fa64cc3776c5fad8c16" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forged-trace/project/lexlean.lock b/tests/negative/reasoning-forged-trace/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-forged-trace/project/lexlean.lock +++ b/tests/negative/reasoning-forged-trace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-formal-rule/project/lexlean.lock b/tests/negative/reasoning-formal-rule/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-formal-rule/project/lexlean.lock +++ b/tests/negative/reasoning-formal-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-claims/project/lexlean.lock b/tests/negative/reasoning-generate-claims/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generate-claims/project/lexlean.lock +++ b/tests/negative/reasoning-generate-claims/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock +++ b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generator-type/project/lexlean.lock b/tests/negative/reasoning-generator-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-generator-type/project/lexlean.lock +++ b/tests/negative/reasoning-generator-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-initial-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-interface-rebound/project/lexlean.lock b/tests/negative/reasoning-interface-rebound/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-interface-rebound/project/lexlean.lock +++ b/tests/negative/reasoning-interface-rebound/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock +++ b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-invariant-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock +++ b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-no-rules/project/lexlean.lock b/tests/negative/reasoning-no-rules/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-no-rules/project/lexlean.lock +++ b/tests/negative/reasoning-no-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock +++ b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-type/project/lexlean.lock b/tests/negative/reasoning-observation-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-observation-type/project/lexlean.lock +++ b/tests/negative/reasoning-observation-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-opaque-member/project/lexlean.lock b/tests/negative/reasoning-opaque-member/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-opaque-member/project/lexlean.lock +++ b/tests/negative/reasoning-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-ranking-signature/project/lexlean.lock b/tests/negative/reasoning-ranking-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-ranking-signature/project/lexlean.lock +++ b/tests/negative/reasoning-ranking-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock +++ b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-signature/project/lexlean.lock b/tests/negative/reasoning-relation-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-relation-signature/project/lexlean.lock +++ b/tests/negative/reasoning-relation-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass/project/lexlean.lock b/tests/negative/reasoning-rule-bypass/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-bypass/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-specification-signature/project/lexlean.lock b/tests/negative/reasoning-specification-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-specification-signature/project/lexlean.lock +++ b/tests/negative/reasoning-specification-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminating-search/project/lexlean.lock b/tests/negative/reasoning-terminating-search/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-terminating-search/project/lexlean.lock +++ b/tests/negative/reasoning-terminating-search/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-rule/project/lexlean.lock b/tests/negative/reasoning-unknown-rule/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-unknown-rule/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unverified-answer/project/lexlean.lock b/tests/negative/reasoning-unverified-answer/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-unverified-answer/project/lexlean.lock +++ b/tests/negative/reasoning-unverified-answer/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-signature/project/lexlean.lock b/tests/negative/reasoning-verifier-signature/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-verifier-signature/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-zero-frontier/project/lexlean.lock b/tests/negative/reasoning-zero-frontier/project/lexlean.lock index 7fe7f6b52..d29791309 100644 --- a/tests/negative/reasoning-zero-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-zero-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-cyclic-measure/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock +++ b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-false-evidence/project/lexlean.lock b/tests/negative/recursion-false-evidence/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-false-evidence/project/lexlean.lock +++ b/tests/negative/recursion-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-forged-evidence/project/lexlean.lock b/tests/negative/recursion-forged-evidence/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-forged-evidence/project/lexlean.lock +++ b/tests/negative/recursion-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-member-under-lambda/project/lexlean.lock b/tests/negative/recursion-member-under-lambda/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-member-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-member-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-case/project/lexlean.lock b/tests/negative/recursion-missing-case/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-missing-case/project/lexlean.lock +++ b/tests/negative/recursion-missing-case/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-evidence/project/lexlean.lock b/tests/negative/recursion-missing-evidence/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-missing-evidence/project/lexlean.lock +++ b/tests/negative/recursion-missing-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mixed-families/project/lexlean.lock b/tests/negative/recursion-mixed-families/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-mixed-families/project/lexlean.lock +++ b/tests/negative/recursion-mixed-families/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock +++ b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock +++ b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-mixed/project/lexlean.lock b/tests/negative/recursion-mutual-mixed/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-mutual-mixed/project/lexlean.lock +++ b/tests/negative/recursion-mutual-mixed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-nondecreasing/project/lexlean.lock b/tests/negative/recursion-nondecreasing/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-nondecreasing/project/lexlean.lock +++ b/tests/negative/recursion-nondecreasing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-under-lambda/project/lexlean.lock b/tests/negative/recursion-under-lambda/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-well-founded-reference/project/lexlean.lock b/tests/negative/recursion-well-founded-reference/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-well-founded-reference/project/lexlean.lock +++ b/tests/negative/recursion-well-founded-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-wrong-argument/project/lexlean.lock b/tests/negative/recursion-wrong-argument/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursion-wrong-argument/project/lexlean.lock +++ b/tests/negative/recursion-wrong-argument/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock +++ b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock +++ b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-structure/project/lexlean.lock b/tests/negative/recursive-structure/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-structure/project/lexlean.lock +++ b/tests/negative/recursive-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-arguments/project/lexlean.lock b/tests/negative/recursive-type-arguments/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-type-arguments/project/lexlean.lock +++ b/tests/negative/recursive-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-forward/project/lexlean.lock b/tests/negative/recursive-type-forward/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-type-forward/project/lexlean.lock +++ b/tests/negative/recursive-type-forward/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-nonuniform/project/lexlean.lock b/tests/negative/recursive-type-nonuniform/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-type-nonuniform/project/lexlean.lock +++ b/tests/negative/recursive-type-nonuniform/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-positivity/project/lexlean.lock b/tests/negative/recursive-type-positivity/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-type-positivity/project/lexlean.lock +++ b/tests/negative/recursive-type-positivity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-uninhabited/project/lexlean.lock b/tests/negative/recursive-type-uninhabited/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/recursive-type-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-type-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock +++ b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-argument-universe/project/lexlean.lock b/tests/negative/type-argument-universe/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/type-argument-universe/project/lexlean.lock +++ b/tests/negative/type-argument-universe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-parameter-capture/project/lexlean.lock b/tests/negative/type-parameter-capture/project/lexlean.lock index f326b4b18..a84849b34 100644 --- a/tests/negative/type-parameter-capture/project/lexlean.lock +++ b/tests/negative/type-parameter-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/production-export/production-coverage/packages/rust-core/bits/package.json b/tests/production-export/production-coverage/packages/rust-core/bits/package.json index 64f8b2411..591e31b2a 100644 --- a/tests/production-export/production-coverage/packages/rust-core/bits/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/bits/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"bits","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"3"}}],"operation":{"kind":"shift_right"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"bits","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"3"}}],"operation":{"kind":"shift_right"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/bits/provenance.json b/tests/production-export/production-coverage/packages/rust-core/bits/provenance.json index 2d27f015f..1560ab705 100644 --- a/tests/production-export/production-coverage/packages/rust-core/bits/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/bits/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fbd9afdc5b19669c491fb8be9e6f9578e6715f7244aa0adb013ad42263077a4d","src/lib.rs":"49c793ee46756c6d514289abbdd0cd8d2dd62bac8312bc2a1c90ff74d7a8fa4c"},"name":"bits","profile":"rust-core","program":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fbd9afdc5b19669c491fb8be9e6f9578e6715f7244aa0adb013ad42263077a4d","src/lib.rs":"49c793ee46756c6d514289abbdd0cd8d2dd62bac8312bc2a1c90ff74d7a8fa4c"},"name":"bits","profile":"rust-core","program":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/builders/package.json b/tests/production-export/production-coverage/packages/rust-core/builders/package.json index f4ab0926b..e026271b7 100644 --- a/tests/production-export/production-coverage/packages/rust-core/builders/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/builders/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"builders","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"succ"},"type":{"kind":"nat"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"zero"},"type":{"kind":"nat"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"builders","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"succ"},"type":{"kind":"nat"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"zero"},"type":{"kind":"nat"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/builders/provenance.json b/tests/production-export/production-coverage/packages/rust-core/builders/provenance.json index b49fcdd57..2e1ede3bb 100644 --- a/tests/production-export/production-coverage/packages/rust-core/builders/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/builders/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fafa24144f14cc940ca1e3c16043130877f447f6beb7975029ea5e9cfd45cff4","src/lib.rs":"7801814468d34df54faeffe9207e61324bba1d83e29d113ead27eb9195312b87"},"name":"builders","profile":"rust-core","program":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fafa24144f14cc940ca1e3c16043130877f447f6beb7975029ea5e9cfd45cff4","src/lib.rs":"7801814468d34df54faeffe9207e61324bba1d83e29d113ead27eb9195312b87"},"name":"builders","profile":"rust-core","program":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/conversions/package.json b/tests/production-export/production-coverage/packages/rust-core/conversions/package.json index 58a6e1259..0d7e6781a 100644 --- a/tests/production-export/production-coverage/packages/rust-core/conversions/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/conversions/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"conversions","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"conversions","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/conversions/provenance.json b/tests/production-export/production-coverage/packages/rust-core/conversions/provenance.json index 4f3a8ae6d..f1e0491ad 100644 --- a/tests/production-export/production-coverage/packages/rust-core/conversions/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/conversions/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fa3523bd7088be5264998e9685661cde4aa5d182d6f8dd083cb5130c7f1fe39b","src/lib.rs":"3ea51441d8082bca46bcb3c8e2caba9345a5408ce677292a985f169d6661994a"},"name":"conversions","profile":"rust-core","program":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fa3523bd7088be5264998e9685661cde4aa5d182d6f8dd083cb5130c7f1fe39b","src/lib.rs":"3ea51441d8082bca46bcb3c8e2caba9345a5408ce677292a985f169d6661994a"},"name":"conversions","profile":"rust-core","program":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_middle/package.json b/tests/production-export/production-coverage/packages/rust-core/fixed_middle/package.json index 3035c1af1..fb33cd28a 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_middle/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_middle/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_middle","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-7"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"3"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_middle","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-7"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"3"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_middle/provenance.json b/tests/production-export/production-coverage/packages/rust-core/fixed_middle/provenance.json index 798c38924..6d96a1159 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_middle/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_middle/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70d81e8cefb299340d3a62dc48f2c63bec855c62563bffbbb15981b963bf8764","src/lib.rs":"f308cdfc8f1d2fa043a39c472851858aeec0fa24616abc115e3194e5eea42ccc"},"name":"fixed_middle","profile":"rust-core","program":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70d81e8cefb299340d3a62dc48f2c63bec855c62563bffbbb15981b963bf8764","src/lib.rs":"f308cdfc8f1d2fa043a39c472851858aeec0fa24616abc115e3194e5eea42ccc"},"name":"fixed_middle","profile":"rust-core","program":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_small/package.json b/tests/production-export/production-coverage/packages/rust-core/fixed_small/package.json index ea123fe24..c67a0d45d 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_small/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_small/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_small","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_small","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_small/provenance.json b/tests/production-export/production-coverage/packages/rust-core/fixed_small/provenance.json index b818f313b..2d39a4c4d 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_small/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_small/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce31af3f31d522467497872c4f9ca4a03022315e9de1c0f4e00f2ee5f92ef058","src/lib.rs":"d077e1a08c789158986baece65130b95ed7a95a670d2c90f551977d2135f1df3"},"name":"fixed_small","profile":"rust-core","program":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce31af3f31d522467497872c4f9ca4a03022315e9de1c0f4e00f2ee5f92ef058","src/lib.rs":"d077e1a08c789158986baece65130b95ed7a95a670d2c90f551977d2135f1df3"},"name":"fixed_small","profile":"rust-core","program":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_wide/package.json b/tests/production-export/production-coverage/packages/rust-core/fixed_wide/package.json index 1639aadae..a6c1cc31d 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_wide/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_wide/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_wide","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_wide","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/fixed_wide/provenance.json b/tests/production-export/production-coverage/packages/rust-core/fixed_wide/provenance.json index c5810e9ff..088be5567 100644 --- a/tests/production-export/production-coverage/packages/rust-core/fixed_wide/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/fixed_wide/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f1666bc680f131b93f6a000603f0f2798622e79f6fac14abd8a5e0d7341fdae","src/lib.rs":"f0f0a8c0cad1a71dd63fb172c31c1d60db20313104463a6f150afca4d891cd40"},"name":"fixed_wide","profile":"rust-core","program":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f1666bc680f131b93f6a000603f0f2798622e79f6fac14abd8a5e0d7341fdae","src/lib.rs":"f0f0a8c0cad1a71dd63fb172c31c1d60db20313104463a6f150afca4d891cd40"},"name":"fixed_wide","profile":"rust-core","program":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/higher/package.json b/tests/production-export/production-coverage/packages/rust-core/higher/package.json index fa33c9da1..47e4ba40e 100644 --- a/tests/production-export/production-coverage/packages/rust-core/higher/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/higher/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"higher","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":2},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"captures":[{"kind":"var","name":2}],"function":3,"kind":"closure"}},{"function":1,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"higher","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":2},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"captures":[{"kind":"var","name":2}],"function":3,"kind":"closure"}},{"function":1,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/higher/provenance.json b/tests/production-export/production-coverage/packages/rust-core/higher/provenance.json index 0dbfd49b6..3fed31937 100644 --- a/tests/production-export/production-coverage/packages/rust-core/higher/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/higher/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a9965766740afeb45706683c1c941095c32f92781e171be35737261a61b8a24a","src/lib.rs":"265af29f14586a0343afb425c4918da3c6055dbaf73b24cfc610a027da1e0809"},"name":"higher","profile":"rust-core","program":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a9965766740afeb45706683c1c941095c32f92781e171be35737261a61b8a24a","src/lib.rs":"265af29f14586a0343afb425c4918da3c6055dbaf73b24cfc610a027da1e0809"},"name":"higher","profile":"rust-core","program":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/int_ops/package.json b/tests/production-export/production-coverage/packages/rust-core/int_ops/package.json index 025754fac..ddd86506f 100644 --- a/tests/production-export/production-coverage/packages/rust-core/int_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/int_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"int_ops","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"int_mul"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_quot"}},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}}],"operation":{"kind":"int_neg"}}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"int_ops","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"int_mul"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_quot"}},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}}],"operation":{"kind":"int_neg"}}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/int_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-core/int_ops/provenance.json index 87a6bee08..f23b3866c 100644 --- a/tests/production-export/production-coverage/packages/rust-core/int_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/int_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fc1efbb5b6ec479184b12aceea00af517df40c0ba110f9c286361df08f0b2142","src/lib.rs":"7502713652008d39229ab08441a2904fb8426cd37d4c20285e519730fdc22593"},"name":"int_ops","profile":"rust-core","program":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fc1efbb5b6ec479184b12aceea00af517df40c0ba110f9c286361df08f0b2142","src/lib.rs":"7502713652008d39229ab08441a2904fb8426cd37d4c20285e519730fdc22593"},"name":"int_ops","profile":"rust-core","program":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/nat_ops/package.json b/tests/production-export/production-coverage/packages/rust-core/nat_ops/package.json index 89547dcab..6ba4a7503 100644 --- a/tests/production-export/production-coverage/packages/rust-core/nat_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/nat_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"nat_ops","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_not"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"nat_ops","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_not"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/nat_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-core/nat_ops/provenance.json index b3ca56044..f1e3a94a7 100644 --- a/tests/production-export/production-coverage/packages/rust-core/nat_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/nat_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"59cd8633f12e3fac8ffcf39b00cfe0eae72e66af298eab94fb7a158d60c11ef2","src/lib.rs":"ec5552329b8cb6b83bf136310a623cb1e7489cfafb2a21b230cfc4f8447c51fa"},"name":"nat_ops","profile":"rust-core","program":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"59cd8633f12e3fac8ffcf39b00cfe0eae72e66af298eab94fb7a158d60c11ef2","src/lib.rs":"ec5552329b8cb6b83bf136310a623cb1e7489cfafb2a21b230cfc4f8447c51fa"},"name":"nat_ops","profile":"rust-core","program":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/options/package.json b/tests/production-export/production-coverage/packages/rust-core/options/package.json index a81bc50c6..871505b38 100644 --- a/tests/production-export/production-coverage/packages/rust-core/options/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/options/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"options","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"ok"}},{"binders":[4],"body":{"condition":{"kind":"var","name":4},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"options","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"ok"}},{"binders":[4],"body":{"condition":{"kind":"var","name":4},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/options/provenance.json b/tests/production-export/production-coverage/packages/rust-core/options/provenance.json index 909d5de19..4a7930e93 100644 --- a/tests/production-export/production-coverage/packages/rust-core/options/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/options/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7f0fac10f04b56539a18ecadc9ac9f95f1ceb9be06a3738695181aa3b6a2e9fd","src/lib.rs":"f77a8889a2639195af038d018a863c9a79f14db51278952d1da5ce206bd668eb"},"name":"options","profile":"rust-core","program":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7f0fac10f04b56539a18ecadc9ac9f95f1ceb9be06a3738695181aa3b6a2e9fd","src/lib.rs":"f77a8889a2639195af038d018a863c9a79f14db51278952d1da5ce206bd668eb"},"name":"options","profile":"rust-core","program":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/pairs/package.json b/tests/production-export/production-coverage/packages/rust-core/pairs/package.json index cf3606421..9d11f9f05 100644 --- a/tests/production-export/production-coverage/packages/rust-core/pairs/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/pairs/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"pairs","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"first","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"pairs","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"first","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/pairs/provenance.json b/tests/production-export/production-coverage/packages/rust-core/pairs/provenance.json index 33943c599..76abaa2c9 100644 --- a/tests/production-export/production-coverage/packages/rust-core/pairs/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/pairs/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a3dd557c4339d106e7e177364f68702e05259c1cdf7bcc15c6c3801657acecac","src/lib.rs":"a9910a7ac532e077a17ffd14206ae6375907126e8ab304cecd17ee1ba5ab1085"},"name":"pairs","profile":"rust-core","program":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a3dd557c4339d106e7e177364f68702e05259c1cdf7bcc15c6c3801657acecac","src/lib.rs":"a9910a7ac532e077a17ffd14206ae6375907126e8ab304cecd17ee1ba5ab1085"},"name":"pairs","profile":"rust-core","program":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/parity/package.json b/tests/production-export/production-coverage/packages/rust-core/parity/package.json index b643274ea..fb7bc6d21 100644 --- a/tests/production-export/production-coverage/packages/rust-core/parity/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/parity/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"parity","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"parity","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/parity/provenance.json b/tests/production-export/production-coverage/packages/rust-core/parity/provenance.json index bb4119951..b42fae4d1 100644 --- a/tests/production-export/production-coverage/packages/rust-core/parity/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/parity/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6eec599d19aab86b6e6c59ee909f6f5478461263e25000e7bc26f67766ef73df","src/lib.rs":"4dfb8beb700c9adbe0abd49585b4691238db30689d7c0edfbe4601268210a8a5"},"name":"parity","profile":"rust-core","program":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6eec599d19aab86b6e6c59ee909f6f5478461263e25000e7bc26f67766ef73df","src/lib.rs":"4dfb8beb700c9adbe0abd49585b4691238db30689d7c0edfbe4601268210a8a5"},"name":"parity","profile":"rust-core","program":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/records/package.json b/tests/production-export/production-coverage/packages/rust-core/records/package.json index 72ffc95d5..59e1222bd 100644 --- a/tests/production-export/production-coverage/packages/rust-core/records/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/records/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"records","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"function":1,"kind":"call","operands":[]}}],"operation":{"kind":"nat_add"}},{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":2}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"let","name":2,"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"parameters":[],"result":{"index":2,"kind":"adt"},"types":[]},{"body":{"index":0,"kind":"field","value":{"kind":"var","name":0}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"records","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"function":1,"kind":"call","operands":[]}}],"operation":{"kind":"nat_add"}},{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":2}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"let","name":2,"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"parameters":[],"result":{"index":2,"kind":"adt"},"types":[]},{"body":{"index":0,"kind":"field","value":{"kind":"var","name":0}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/records/provenance.json b/tests/production-export/production-coverage/packages/rust-core/records/provenance.json index 2038bc055..37aa73772 100644 --- a/tests/production-export/production-coverage/packages/rust-core/records/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/records/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75a1f2726772f72e4e3d6999f4a2e57d1b02c3dfada582fcf741f36a7e68aab8","src/lib.rs":"75717c93f7eb083027fd65ec26fa8633f3b7d2f89c29fca9ce3e3cc7cc676429"},"name":"records","profile":"rust-core","program":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75a1f2726772f72e4e3d6999f4a2e57d1b02c3dfada582fcf741f36a7e68aab8","src/lib.rs":"75717c93f7eb083027fd65ec26fa8633f3b7d2f89c29fca9ce3e3cc7cc676429"},"name":"records","profile":"rust-core","program":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/shapes/package.json b/tests/production-export/production-coverage/packages/rust-core/shapes/package.json index 02313167a..320d9ce4a 100644 --- a/tests/production-export/production-coverage/packages/rust-core/shapes/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shapes","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}],[]]}],"functions":[{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shapes","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}],[]]}],"functions":[{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/shapes/provenance.json b/tests/production-export/production-coverage/packages/rust-core/shapes/provenance.json index 76c3dec51..81c63b93c 100644 --- a/tests/production-export/production-coverage/packages/rust-core/shapes/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f2da6540473eb8c30328ec5522a3a0d931e34392c6720ac9842e96878fa8fd5","src/lib.rs":"cf488904e65fcc775e3ab609f6586188eef2038d7821c5e303effdb5cfc3033d"},"name":"shapes","profile":"rust-core","program":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f2da6540473eb8c30328ec5522a3a0d931e34392c6720ac9842e96878fa8fd5","src/lib.rs":"cf488904e65fcc775e3ab609f6586188eef2038d7821c5e303effdb5cfc3033d"},"name":"shapes","profile":"rust-core","program":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/well_founded/package.json b/tests/production-export/production-coverage/packages/rust-core/well_founded/package.json index cce7cb29e..961d2ae69 100644 --- a/tests/production-export/production-coverage/packages/rust-core/well_founded/package.json +++ b/tests/production-export/production-coverage/packages/rust-core/well_founded/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"well_founded","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":2,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"var","name":0}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}]},"kind":"cond","then_branch":{"kind":"var","name":1}}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"well_founded","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":2,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"var","name":0}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}]},"kind":"cond","then_branch":{"kind":"var","name":1}}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-core/well_founded/provenance.json b/tests/production-export/production-coverage/packages/rust-core/well_founded/provenance.json index 9905e751d..8c1997d29 100644 --- a/tests/production-export/production-coverage/packages/rust-core/well_founded/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-core/well_founded/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0c780ccff965ccc10faa78b2714b324aa2f72bb88aedc1f0632079faded0b0d8","src/lib.rs":"0c41a66fccc35c507f10b37bae86e81f68d0076d3468125efc9f2d8a347e7812"},"name":"well_founded","profile":"rust-core","program":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0c780ccff965ccc10faa78b2714b324aa2f72bb88aedc1f0632079faded0b0d8","src/lib.rs":"0c41a66fccc35c507f10b37bae86e81f68d0076d3468125efc9f2d8a347e7812"},"name":"well_founded","profile":"rust-core","program":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/bits/package.json b/tests/production-export/production-coverage/packages/rust-std/bits/package.json index 54b69e29e..84ae132d7 100644 --- a/tests/production-export/production-coverage/packages/rust-std/bits/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/bits/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"bits","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"3"}}],"operation":{"kind":"shift_right"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"bits","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_and"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_or"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"bit_xor"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"bit_not"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"shift_left"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"3"}}],"operation":{"kind":"shift_right"}},{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"fixed","width":"u16"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u16"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/bits/provenance.json b/tests/production-export/production-coverage/packages/rust-std/bits/provenance.json index 35fd11628..484e5380e 100644 --- a/tests/production-export/production-coverage/packages/rust-std/bits/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/bits/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fbd9afdc5b19669c491fb8be9e6f9578e6715f7244aa0adb013ad42263077a4d","src/lib.rs":"28f88d34b240232107b4bdff8b086a3acbbb23df63a5535f4cf58f5f33a920ec"},"name":"bits","profile":"rust-std","program":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fbd9afdc5b19669c491fb8be9e6f9578e6715f7244aa0adb013ad42263077a4d","src/lib.rs":"28f88d34b240232107b4bdff8b086a3acbbb23df63a5535f4cf58f5f33a920ec"},"name":"bits","profile":"rust-std","program":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/builders/package.json b/tests/production-export/production-coverage/packages/rust-std/builders/package.json index 4a2873a26..92a22e0b8 100644 --- a/tests/production-export/production-coverage/packages/rust-std/builders/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/builders/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"builders","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"succ"},"type":{"kind":"nat"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"zero"},"type":{"kind":"nat"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"builders","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"succ"},"type":{"kind":"nat"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"unit"},"type":{"kind":"unit"}}],"shape":{"kind":"error"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"zero"},"type":{"kind":"nat"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"error":{"kind":"unit"},"kind":"result","ok":{"kind":"nat"}}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/builders/provenance.json b/tests/production-export/production-coverage/packages/rust-std/builders/provenance.json index 289612fd7..98dd2152b 100644 --- a/tests/production-export/production-coverage/packages/rust-std/builders/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/builders/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fafa24144f14cc940ca1e3c16043130877f447f6beb7975029ea5e9cfd45cff4","src/lib.rs":"d575ec9360acf95c825535ad667a3ef6d906d216d3d52331f3118010c1bada5b"},"name":"builders","profile":"rust-std","program":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fafa24144f14cc940ca1e3c16043130877f447f6beb7975029ea5e9cfd45cff4","src/lib.rs":"d575ec9360acf95c825535ad667a3ef6d906d216d3d52331f3118010c1bada5b"},"name":"builders","profile":"rust-std","program":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/conversions/package.json b/tests/production-export/production-coverage/packages/rust-std/conversions/package.json index d16960554..f291dda20 100644 --- a/tests/production-export/production-coverage/packages/rust-std/conversions/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/conversions/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"conversions","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"conversions","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"u16"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"convert","target":"i64"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u16"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i64"}}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/conversions/provenance.json b/tests/production-export/production-coverage/packages/rust-std/conversions/provenance.json index 9a710ae89..92949b4eb 100644 --- a/tests/production-export/production-coverage/packages/rust-std/conversions/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/conversions/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fa3523bd7088be5264998e9685661cde4aa5d182d6f8dd083cb5130c7f1fe39b","src/lib.rs":"e0c05cf69833c7f43a18b493542e586f3a0dcb6c30c80ac934a4086c4e3fe1e3"},"name":"conversions","profile":"rust-std","program":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fa3523bd7088be5264998e9685661cde4aa5d182d6f8dd083cb5130c7f1fe39b","src/lib.rs":"e0c05cf69833c7f43a18b493542e586f3a0dcb6c30c80ac934a4086c4e3fe1e3"},"name":"conversions","profile":"rust-std","program":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/decimals/package.json b/tests/production-export/production-coverage/packages/rust-std/decimals/package.json index 97193a1b8..36cc23a60 100644 --- a/tests/production-export/production-coverage/packages/rust-std/decimals/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/decimals/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"decimals","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"int"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"int"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}},"types":[{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"decimals","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"parse_decimal","target":{"kind":"int"}}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"parse_decimal","target":{"kind":"fixed","width":"u32"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"int"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"int"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u32"}}},"types":[{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/decimals/provenance.json b/tests/production-export/production-coverage/packages/rust-std/decimals/provenance.json index 9fbbad95f..c4b2d5f87 100644 --- a/tests/production-export/production-coverage/packages/rust-std/decimals/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/decimals/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"38d68167a4f0b5b10417a9133b3afe780fe8449f038b8124bd97a75578a12b14","src/lib.rs":"1efe2b4f6015da3f7e5ecb18aedf10d5484ac770d347f87d1b9f08d3022d47cc"},"name":"decimals","profile":"rust-std","program":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"38d68167a4f0b5b10417a9133b3afe780fe8449f038b8124bd97a75578a12b14","src/lib.rs":"1efe2b4f6015da3f7e5ecb18aedf10d5484ac770d347f87d1b9f08d3022d47cc"},"name":"decimals","profile":"rust-std","program":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_middle/package.json b/tests/production-export/production-coverage/packages/rust-std/fixed_middle/package.json index f7af4cdbf..09af746d3 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_middle/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_middle/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_middle","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-7"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"3"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_middle","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"-7"}}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"convert","target":"i32"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"i32"},"value":{"kind":"i32","value":"3"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i16"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i32"}},"right":{"kind":"bool"}}}},"types":[{"kind":"fixed","width":"i16"},{"kind":"fixed","width":"i32"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_middle/provenance.json b/tests/production-export/production-coverage/packages/rust-std/fixed_middle/provenance.json index cf58099f9..5a0b45dba 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_middle/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_middle/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70d81e8cefb299340d3a62dc48f2c63bec855c62563bffbbb15981b963bf8764","src/lib.rs":"e3d95cef121ebfda14217535b6bc27db8a10f8de4660094bc76d6657e4ae05b8"},"name":"fixed_middle","profile":"rust-std","program":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"70d81e8cefb299340d3a62dc48f2c63bec855c62563bffbbb15981b963bf8764","src/lib.rs":"e3d95cef121ebfda14217535b6bc27db8a10f8de4660094bc76d6657e4ae05b8"},"name":"fixed_middle","profile":"rust-std","program":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_small/package.json b/tests/production-export/production-coverage/packages/rust-std/fixed_small/package.json index 5ad134719..9ea7be092 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_small/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_small/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_small","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"fixed_small","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i8"}},"right":{"kind":"option","value":{"kind":"fixed","width":"i8"}}}}}},"types":[{"kind":"fixed","width":"i8"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_small/provenance.json b/tests/production-export/production-coverage/packages/rust-std/fixed_small/provenance.json index 8ad3c2c26..e1c7cd9f5 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_small/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_small/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce31af3f31d522467497872c4f9ca4a03022315e9de1c0f4e00f2ee5f92ef058","src/lib.rs":"490ea341ab742d6e0889c4b8f12dc1910ec57426bd74e728143e658b2f77f2ff"},"name":"fixed_small","profile":"rust-std","program":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce31af3f31d522467497872c4f9ca4a03022315e9de1c0f4e00f2ee5f92ef058","src/lib.rs":"490ea341ab742d6e0889c4b8f12dc1910ec57426bd74e728143e658b2f77f2ff"},"name":"fixed_small","profile":"rust-std","program":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_wide/package.json b/tests/production-export/production-coverage/packages/rust-std/fixed_wide/package.json index 055e6fe2f..4a479e65e 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_wide/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_wide/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_wide","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own","own"]}],"name":"fixed_wide","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_mul"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_quot"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"checked_neg"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"fixed","width":"u64"},"value":{"kind":"u64","value":"1"}}],"operation":{"kind":"checked_add"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"i64"}},"right":{"kind":"option","value":{"kind":"fixed","width":"u64"}}}}}}},"types":[{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"i64"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/fixed_wide/provenance.json b/tests/production-export/production-coverage/packages/rust-std/fixed_wide/provenance.json index 68f328473..75d6cf56e 100644 --- a/tests/production-export/production-coverage/packages/rust-std/fixed_wide/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/fixed_wide/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f1666bc680f131b93f6a000603f0f2798622e79f6fac14abd8a5e0d7341fdae","src/lib.rs":"d602a7c44b2c87b7592f08c7680096462d33a7f0a94fe2f2f75217c3a4dd503d"},"name":"fixed_wide","profile":"rust-std","program":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"2f1666bc680f131b93f6a000603f0f2798622e79f6fac14abd8a5e0d7341fdae","src/lib.rs":"d602a7c44b2c87b7592f08c7680096462d33a7f0a94fe2f2f75217c3a4dd503d"},"name":"fixed_wide","profile":"rust-std","program":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/folds/package.json b/tests/production-export/production-coverage/packages/rust-std/folds/package.json index a046ec310..5f9b5c983 100644 --- a/tests/production-export/production-coverage/packages/rust-std/folds/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/folds/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":6,"name":"run","parameters":["own","own"]}],"name":"folds","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"int"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"int"}},"parameters":[0,1,2],"result":{"kind":"int"},"types":[{"kind":"fn","parameters":[{"kind":"int"},{"kind":"int"}],"result":{"kind":"int"}},{"kind":"int"},{"element":{"kind":"int"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":5,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"int"},"kind":"list"}]},{"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"int"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":6,"name":"run","parameters":["own","own"]}],"name":"folds","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},{"function":3,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"5"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"int"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"int"}},"parameters":[0,1,2],"result":{"kind":"int"},"types":[{"kind":"fn","parameters":[{"kind":"int"},{"kind":"int"}],"result":{"kind":"int"}},{"kind":"int"},{"element":{"kind":"int"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":5,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"int"},"kind":"list"}]},{"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"int"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/folds/provenance.json b/tests/production-export/production-coverage/packages/rust-std/folds/provenance.json index 1b464c73c..1b77ebd01 100644 --- a/tests/production-export/production-coverage/packages/rust-std/folds/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/folds/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":6,"name":"run"}],"files":{"Cargo.toml":"21833df3c31669fee6a4dcbc88ec818bce79c0448e84ea927707c0794b480598","src/lib.rs":"c43ae91ecd04414637c50ee825458c0c0116fb91077a54dd6b337b6314ddc6c9"},"name":"folds","profile":"rust-std","program":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":6,"name":"run"}],"files":{"Cargo.toml":"21833df3c31669fee6a4dcbc88ec818bce79c0448e84ea927707c0794b480598","src/lib.rs":"c43ae91ecd04414637c50ee825458c0c0116fb91077a54dd6b337b6314ddc6c9"},"name":"folds","profile":"rust-std","program":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/formats/package.json b/tests/production-export/production-coverage/packages/rust-std/formats/package.json index 58316d6f5..7391a2751 100644 --- a/tests/production-export/production-coverage/packages/rust-std/formats/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/formats/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"formats","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"format_decimal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"formats","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"format_decimal"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"format_decimal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"string"}},"types":[{"kind":"int"},{"kind":"fixed","width":"i8"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/formats/provenance.json b/tests/production-export/production-coverage/packages/rust-std/formats/provenance.json index 74c055c85..a5998e82c 100644 --- a/tests/production-export/production-coverage/packages/rust-std/formats/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/formats/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e54fd5976089487c24262a84ee4c52b4e352aee3ea4cbf903b03f3beb32b2388","src/lib.rs":"080123c4076700aba965da9cdb74c7592689b3abacb9e1e3ff4bea12fa83e7c0"},"name":"formats","profile":"rust-std","program":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"e54fd5976089487c24262a84ee4c52b4e352aee3ea4cbf903b03f3beb32b2388","src/lib.rs":"080123c4076700aba965da9cdb74c7592689b3abacb9e1e3ff4bea12fa83e7c0"},"name":"formats","profile":"rust-std","program":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/graphs/package.json b/tests/production-export/production-coverage/packages/rust-std/graphs/package.json index 907c32442..2780faf44 100644 --- a/tests/production-export/production-coverage/packages/rust-std/graphs/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/graphs/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":30,"name":"run","parameters":["own","own"]}],"name":"graphs","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":13,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":6,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"function":14,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":15,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":14,"kind":"call","operands":[{"kind":"var","name":3},{"function":15,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":15,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":27,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":26,"kind":"call","operands":[{"function":24,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":21,"kind":"call","operands":[{"kind":"var","name":3},{"function":22,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":23,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":3},{"function":23,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":23,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":25,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":27,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":29,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":28,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":29,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"condition":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":30,"name":"run","parameters":["own","own"]}],"name":"graphs","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":16,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":13,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"zero"}},{"binders":[4],"body":{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[6,7],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"var","name":5},{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":5}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":5},"type":{"element":{"kind":"nat"},"kind":"list"}},"bound":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":5,"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":5},{"function":6,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4}]},{"kind":"var","name":3}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2,3],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"else_branch":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"else_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},"kind":"cond","then_branch":{"kind":"var","name":2}},"kind":"cond","then_branch":{"kind":"var","name":2}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":11,"kind":"call","operands":[{"function":12,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":13,"kind":"call","operands":[{"kind":"var","name":3},{"function":14,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":15,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":14,"kind":"call","operands":[{"kind":"var","name":3},{"function":15,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":15,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"bound":{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":17,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":27,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":26,"kind":"call","operands":[{"function":24,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":20,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":21,"kind":"call","operands":[{"kind":"var","name":3},{"function":22,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":23,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":3},{"function":23,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":23,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":25,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":25,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":27,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":29,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":28,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":29,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"condition":{"function":28,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/graphs/provenance.json b/tests/production-export/production-coverage/packages/rust-std/graphs/provenance.json index d1f62ebcb..7c4cbbb9b 100644 --- a/tests/production-export/production-coverage/packages/rust-std/graphs/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/graphs/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":30,"name":"run"}],"files":{"Cargo.toml":"006bdd268983be958dbe85a51c271f1e7315257d78cce3ed57743b23cd195944","src/lib.rs":"72489cde84069bf6e34c53e43d3b6de78cc4f5e3f9e9117fbd964ae31f85bde7"},"name":"graphs","profile":"rust-std","program":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":30,"name":"run"}],"files":{"Cargo.toml":"006bdd268983be958dbe85a51c271f1e7315257d78cce3ed57743b23cd195944","src/lib.rs":"72489cde84069bf6e34c53e43d3b6de78cc4f5e3f9e9117fbd964ae31f85bde7"},"name":"graphs","profile":"rust-std","program":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/grove_root/package.json b/tests/production-export/production-coverage/packages/rust-std/grove_root/package.json index 0b30073e1..a460ae043 100644 --- a/tests/production-export/production-coverage/packages/rust-std/grove_root/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/grove_root/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":18,"name":"run","parameters":["own","own","own","own"]}],"name":"grove_root","profile":"rust-std","program":{"adts":[{"constructors":[[{"element":{"kind":"nat"},"kind":"list"},{"element":{"index":0,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"},{"kind":"option","value":{"index":0,"kind":"adt"}},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}},"kind":"list"}],[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"kind":"list"}],[{"error":{"kind":"nat"},"kind":"result","ok":{"index":0,"kind":"adt"}}]]},{"constructors":[[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"},{"kind":"string"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}},"parameters":[0,1,2,3],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"},{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]},{"body":{"arms":[{"binders":[1,2,3,4,5],"body":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[6],"body":{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1,2,3,4,5],"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":5}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}}}}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[6],"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7],"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":7}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"index":0,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":5,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"option","value":{"index":0,"kind":"adt"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}},"kind":"list"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":2,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}}]}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"kind":"list"}]},{"body":{"arms":[{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"ok"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"error":{"kind":"nat"},"kind":"result","ok":{"index":0,"kind":"adt"}}]},{"body":{"arms":[{"binders":[1,2],"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":15,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":17,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":16,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bool"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}}}}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"},{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":18,"name":"run","parameters":["own","own","own","own"]}],"name":"grove_root","profile":"rust-std","program":{"adts":[{"constructors":[[{"element":{"kind":"nat"},"kind":"list"},{"element":{"index":0,"kind":"adt"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"},{"kind":"option","value":{"index":0,"kind":"adt"}},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}},"kind":"list"}],[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"kind":"list"}],[{"error":{"kind":"nat"},"kind":"result","ok":{"index":0,"kind":"adt"}}]]},{"constructors":[[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"},{"kind":"string"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}},"parameters":[0,1,2,3],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"},{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]},{"body":{"arms":[{"binders":[1,2,3,4,5],"body":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[6],"body":{"kind":"prim","operands":[{"kind":"var","name":6}],"operation":{"kind":"length"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1,2,3,4,5],"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":5}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}}}}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[6],"body":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7],"body":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":7}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"index":0,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":5,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"int"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"option","value":{"index":0,"kind":"adt"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}},"kind":"list"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"first","value":{"kind":"var","name":0}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":2,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":0}}]}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"index":0,"kind":"adt"}}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"int"}},"kind":"list"}]},{"body":{"arms":[{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"ok"}},{"binders":[2],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"error":{"kind":"nat"},"kind":"result","ok":{"index":0,"kind":"adt"}}]},{"body":{"arms":[{"binders":[1,2],"body":{"condition":{"function":5,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"index":1,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":16,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":15,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":17,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":16,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bool"}]},{"body":{"condition":{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":14,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"condition":{"function":15,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}}}}}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"index":1,"kind":"adt"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}}}}},"types":[{"index":0,"kind":"adt"},{"index":1,"kind":"adt"},{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},{"element":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"kind":"list"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/grove_root/provenance.json b/tests/production-export/production-coverage/packages/rust-std/grove_root/provenance.json index 9e6a5fd6a..a051121b0 100644 --- a/tests/production-export/production-coverage/packages/rust-std/grove_root/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/grove_root/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":18,"name":"run"}],"files":{"Cargo.toml":"cd5f821f98d8f9d0bb49b5e40dbd8213040d1eb56f5ad4d42ca594defb94fafc","src/lib.rs":"f2b1845fe3adad6812c4b57175cd599d4080bdcf865efbce9d06f9c19f6c9706"},"name":"grove_root","profile":"rust-std","program":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":18,"name":"run"}],"files":{"Cargo.toml":"cd5f821f98d8f9d0bb49b5e40dbd8213040d1eb56f5ad4d42ca594defb94fafc","src/lib.rs":"f2b1845fe3adad6812c4b57175cd599d4080bdcf865efbce9d06f9c19f6c9706"},"name":"grove_root","profile":"rust-std","program":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/higher/package.json b/tests/production-export/production-coverage/packages/rust-std/higher/package.json index 75e082c3a..8b1ae6846 100644 --- a/tests/production-export/production-coverage/packages/rust-std/higher/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/higher/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"higher","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":2},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"captures":[{"kind":"var","name":2}],"function":3,"kind":"closure"}},{"function":1,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"higher","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":2},{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"var","name":0}]},{"kind":"prim","operands":[{"kind":"apply","operands":[{"kind":"var","name":0}],"target":{"captures":[{"kind":"var","name":2}],"function":3,"kind":"closure"}},{"function":1,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_mul"}},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"operation":{"kind":"nat_sub"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/higher/provenance.json b/tests/production-export/production-coverage/packages/rust-std/higher/provenance.json index c177a0d83..c32d3c3c7 100644 --- a/tests/production-export/production-coverage/packages/rust-std/higher/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/higher/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a9965766740afeb45706683c1c941095c32f92781e171be35737261a61b8a24a","src/lib.rs":"f82da2f587585cce5a6abd616213045aa57aaee2228a787f540c6b664160238a"},"name":"higher","profile":"rust-std","program":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a9965766740afeb45706683c1c941095c32f92781e171be35737261a61b8a24a","src/lib.rs":"f82da2f587585cce5a6abd616213045aa57aaee2228a787f540c6b664160238a"},"name":"higher","profile":"rust-std","program":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/int_ops/package.json b/tests/production-export/production-coverage/packages/rust-std/int_ops/package.json index 02922a207..d09dcdfbc 100644 --- a/tests/production-export/production-coverage/packages/rust-std/int_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/int_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"int_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"int_mul"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_quot"}},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}}],"operation":{"kind":"int_neg"}}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"int_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"-3"}}],"operation":{"kind":"int_mul"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"1"}}],"operation":{"kind":"int_quot"}},{"kind":"var","name":1},{"kind":"value","type":{"kind":"int"},"value":{"kind":"int","value":"0"}}],"operation":{"kind":"int_rem"}}],"operation":{"kind":"int_neg"}}],"operation":{"kind":"int_sub"}},"parameters":[0,1],"result":{"kind":"int"},"types":[{"kind":"int"},{"kind":"int"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/int_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-std/int_ops/provenance.json index c11d705cb..7b09ed0c1 100644 --- a/tests/production-export/production-coverage/packages/rust-std/int_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/int_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fc1efbb5b6ec479184b12aceea00af517df40c0ba110f9c286361df08f0b2142","src/lib.rs":"ca5bbe334ad23a550d260ec243a6be249a61f249e733bb1433d582487d85c287"},"name":"int_ops","profile":"rust-std","program":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"fc1efbb5b6ec479184b12aceea00af517df40c0ba110f9c286361df08f0b2142","src/lib.rs":"ca5bbe334ad23a550d260ec243a6be249a61f249e733bb1433d582487d85c287"},"name":"int_ops","profile":"rust-std","program":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/iterations/package.json b/tests/production-export/production-coverage/packages/rust-std/iterations/package.json index fb05e6fd6..1ca101018 100644 --- a/tests/production-export/production-coverage/packages/rust-std/iterations/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/iterations/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"iterations","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"iterations","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"captures":[],"function":4,"kind":"closure"},{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":2},"shape":{"kind":"zero"}},{"binders":[3],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/iterations/provenance.json b/tests/production-export/production-coverage/packages/rust-std/iterations/provenance.json index 74a2bd395..54fe9f3a0 100644 --- a/tests/production-export/production-coverage/packages/rust-std/iterations/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/iterations/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"30538a8c312a4083ac5aaaa7ae38d9ab7689cd5c311aafa494a6add82a0481d2","src/lib.rs":"0a86c1df2c70a18f50c6d51d8d31e7efc17b44a7f90e7ea754acbd0782ce8364"},"name":"iterations","profile":"rust-std","program":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"30538a8c312a4083ac5aaaa7ae38d9ab7689cd5c311aafa494a6add82a0481d2","src/lib.rs":"0a86c1df2c70a18f50c6d51d8d31e7efc17b44a7f90e7ea754acbd0782ce8364"},"name":"iterations","profile":"rust-std","program":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/key_types/package.json b/tests/production-export/production-coverage/packages/rust-std/key_types/package.json index b5a1b4ac0..2914bd257 100644 --- a/tests/production-export/production-coverage/packages/rust-std/key_types/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/key_types/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":13,"name":"run","parameters":["own","own","own","own","own","own","own","own","own","own"]}],"name":"key_types","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":5}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":6},{"kind":"var","name":7}]},{"function":5,"kind":"call","operands":[{"kind":"var","name":8},{"kind":"var","name":9}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}},"parameters":[0,1,2,3,4,5,6,7,8,9],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"},{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"},{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"},{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"bool"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bool"}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":6,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":12,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":8}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3},{"kind":"var","name":4},{"kind":"var","name":5},{"kind":"var","name":6},{"kind":"var","name":7},{"kind":"var","name":8},{"kind":"var","name":9}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}}}}}}},"parameters":[0,1,2,3,4,5,6,7,8,9],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"},{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"},{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"},{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":13,"name":"run","parameters":["own","own","own","own","own","own","own","own","own","own"]}],"name":"key_types","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":3}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":5}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":6},{"kind":"var","name":7}]},{"function":5,"kind":"call","operands":[{"kind":"var","name":8},{"kind":"var","name":9}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}},"parameters":[0,1,2,3,4,5,6,7,8,9],"result":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"},{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"},{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"},{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"bool"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bool"}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":6,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bool"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":12,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":11,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":12,"kind":"call","operands":[{"kind":"var","name":8}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3},{"kind":"var","name":4},{"kind":"var","name":5},{"kind":"var","name":6},{"kind":"var","name":7},{"kind":"var","name":8},{"kind":"var","name":9}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}}}}}}}},"parameters":[0,1,2,3,4,5,6,7,8,9],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"option","value":{"kind":"bool"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"option","value":{"kind":"nat"}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},"right":{"kind":"bool"}},"kind":"list"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"string"}},{"element":{"kind":"pair","left":{"kind":"fixed","width":"i8"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"i8"},{"element":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"bool"},{"element":{"kind":"pair","left":{"kind":"int"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"int"},{"element":{"kind":"pair","left":{"kind":"fixed","width":"u64"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"fixed","width":"u64"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/key_types/provenance.json b/tests/production-export/production-coverage/packages/rust-std/key_types/provenance.json index 915669757..182b6c28f 100644 --- a/tests/production-export/production-coverage/packages/rust-std/key_types/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/key_types/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":13,"name":"run"}],"files":{"Cargo.toml":"9cecbb64ae81b051d99238533458e614535b89a97d68038a37dc146d7b713075","src/lib.rs":"2e7d46426b92417e89c52e95a2a86b5428d20cc33310d05167864a748ffc79e6"},"name":"key_types","profile":"rust-std","program":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":13,"name":"run"}],"files":{"Cargo.toml":"9cecbb64ae81b051d99238533458e614535b89a97d68038a37dc146d7b713075","src/lib.rs":"2e7d46426b92417e89c52e95a2a86b5428d20cc33310d05167864a748ffc79e6"},"name":"key_types","profile":"rust-std","program":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/literals/package.json b/tests/production-export/production-coverage/packages/rust-std/literals/package.json index 83152a3d9..783a2a8b8 100644 --- a/tests/production-export/production-coverage/packages/rust-std/literals/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/literals/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"literals","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"b"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}},"types":[{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"literals","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"a"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"b"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}},"kind":"list"}}},"types":[{"kind":"nat"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/literals/provenance.json b/tests/production-export/production-coverage/packages/rust-std/literals/provenance.json index 3de1bb440..04b78a490 100644 --- a/tests/production-export/production-coverage/packages/rust-std/literals/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/literals/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d50f03397a2a5fa453e54d825b4cc78390b490b4973fe40536246e21fa86ef38","src/lib.rs":"5b9440cfbe529b300f326669cd3186d65d2fd758984e30598c0c2ec62f448784"},"name":"literals","profile":"rust-std","program":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d50f03397a2a5fa453e54d825b4cc78390b490b4973fe40536246e21fa86ef38","src/lib.rs":"5b9440cfbe529b300f326669cd3186d65d2fd758984e30598c0c2ec62f448784"},"name":"literals","profile":"rust-std","program":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/map_folding/package.json b/tests/production-export/production-coverage/packages/rust-std/map_folding/package.json index d5f425d74..08b001ef8 100644 --- a/tests/production-export/production-coverage/packages/rust-std/map_folding/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/map_folding/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":5,"name":"run","parameters":["own","own"]}],"name":"map_folding","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}},{"kind":"second","value":{"kind":"var","name":3}}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2,3],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":5,"name":"run","parameters":["own","own"]}],"name":"map_folding","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}},{"kind":"second","value":{"kind":"var","name":3}}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1,2,3],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/map_folding/provenance.json b/tests/production-export/production-coverage/packages/rust-std/map_folding/provenance.json index 55076e4f5..8d2fbdaa3 100644 --- a/tests/production-export/production-coverage/packages/rust-std/map_folding/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/map_folding/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":5,"name":"run"}],"files":{"Cargo.toml":"e20682f7e1258bfdb39c7012f02acd610ed6215570067732977bd5a1e9318152","src/lib.rs":"478e0a5ef288094018bf4e4b4dd4e8ea02a890c41253fef33c194130fecb119d"},"name":"map_folding","profile":"rust-std","program":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":5,"name":"run"}],"files":{"Cargo.toml":"e20682f7e1258bfdb39c7012f02acd610ed6215570067732977bd5a1e9318152","src/lib.rs":"478e0a5ef288094018bf4e4b4dd4e8ea02a890c41253fef33c194130fecb119d"},"name":"map_folding","profile":"rust-std","program":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/map_ops/package.json b/tests/production-export/production-coverage/packages/rust-std/map_ops/package.json index a4a398001..981f1bcdf 100644 --- a/tests/production-export/production-coverage/packages/rust-std/map_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/map_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":10,"name":"run","parameters":["own","own","own"]}],"name":"map_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"function":6,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":7,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":10,"name":"run","parameters":["own","own","own"]}],"name":"map_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"function":7,"kind":"call","operands":[{"kind":"var","name":0}]},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}}},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":3},{"function":1,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"kind":"nat"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"nat"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"function":6,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":7,"kind":"call","operands":[{"kind":"var","name":2}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}]},{"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"string"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"}}}}}}}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"nat"}},"kind":"list"},{"kind":"string"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/map_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-std/map_ops/provenance.json index e799985f2..b45cd534c 100644 --- a/tests/production-export/production-coverage/packages/rust-std/map_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/map_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":10,"name":"run"}],"files":{"Cargo.toml":"adebd8e382f9c7ef2503c46c04e30f3fa80125dba1bb356f1ae0361d4958dac4","src/lib.rs":"74e57de6fc14045e08ffa6efec190aafbb5404429d63778b4a7b9509dc75170e"},"name":"map_ops","profile":"rust-std","program":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":10,"name":"run"}],"files":{"Cargo.toml":"adebd8e382f9c7ef2503c46c04e30f3fa80125dba1bb356f1ae0361d4958dac4","src/lib.rs":"74e57de6fc14045e08ffa6efec190aafbb5404429d63778b4a7b9509dc75170e"},"name":"map_ops","profile":"rust-std","program":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/mapped/package.json b/tests/production-export/production-coverage/packages/rust-std/mapped/package.json index 4e68e3285..ed488bc93 100644 --- a/tests/production-export/production-coverage/packages/rust-std/mapped/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/mapped/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"mapped","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"bool"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"mapped","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"build","operands":[{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bool"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"bool"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bool"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"bool"}},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/mapped/provenance.json b/tests/production-export/production-coverage/packages/rust-std/mapped/provenance.json index 261d7e121..b7fb944a2 100644 --- a/tests/production-export/production-coverage/packages/rust-std/mapped/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/mapped/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"74d20143e44a79d9f19bf361224c94504bf0af1c0270595f0d3e089ac3edee9c","src/lib.rs":"6d08d4eef8ef893a1e44d7791e0dc20b8145982029ce00ae2141bb9b8001ce05"},"name":"mapped","profile":"rust-std","program":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"74d20143e44a79d9f19bf361224c94504bf0af1c0270595f0d3e089ac3edee9c","src/lib.rs":"6d08d4eef8ef893a1e44d7791e0dc20b8145982029ce00ae2141bb9b8001ce05"},"name":"mapped","profile":"rust-std","program":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/nat_ops/package.json b/tests/production-export/production-coverage/packages/rust-std/nat_ops/package.json index 90975b140..a46bf657b 100644 --- a/tests/production-export/production-coverage/packages/rust-std/nat_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/nat_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"nat_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_not"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"nat_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}}],"operation":{"kind":"bool_not"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"7"}}],"operation":{"kind":"nat_quot"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/nat_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-std/nat_ops/provenance.json index 40b8e2975..93e5c3fd2 100644 --- a/tests/production-export/production-coverage/packages/rust-std/nat_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/nat_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"59cd8633f12e3fac8ffcf39b00cfe0eae72e66af298eab94fb7a158d60c11ef2","src/lib.rs":"5f05eb70ed8f42dc70c25bc003d949c109c60e5f9cacdcdd12a2b392d931ca7c"},"name":"nat_ops","profile":"rust-std","program":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"59cd8633f12e3fac8ffcf39b00cfe0eae72e66af298eab94fb7a158d60c11ef2","src/lib.rs":"5f05eb70ed8f42dc70c25bc003d949c109c60e5f9cacdcdd12a2b392d931ca7c"},"name":"nat_ops","profile":"rust-std","program":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/options/package.json b/tests/production-export/production-coverage/packages/rust-std/options/package.json index 6c213f938..a77290807 100644 --- a/tests/production-export/production-coverage/packages/rust-std/options/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/options/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"options","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"ok"}},{"binders":[4],"body":{"condition":{"kind":"var","name":4},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"options","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"ok"}},{"binders":[4],"body":{"condition":{"kind":"var","name":4},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"shape":{"kind":"error"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"nat"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"option","value":{"kind":"nat"}},{"error":{"kind":"bool"},"kind":"result","ok":{"kind":"nat"}}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/options/provenance.json b/tests/production-export/production-coverage/packages/rust-std/options/provenance.json index dc42c936e..917387b8c 100644 --- a/tests/production-export/production-coverage/packages/rust-std/options/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/options/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7f0fac10f04b56539a18ecadc9ac9f95f1ceb9be06a3738695181aa3b6a2e9fd","src/lib.rs":"f4911d06380e55018526f1c48f5de31724916e3ebc587a7934519d70cf02bfb7"},"name":"options","profile":"rust-std","program":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"7f0fac10f04b56539a18ecadc9ac9f95f1ceb9be06a3738695181aa3b6a2e9fd","src/lib.rs":"f4911d06380e55018526f1c48f5de31724916e3ebc587a7934519d70cf02bfb7"},"name":"options","profile":"rust-std","program":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/pairs/package.json b/tests/production-export/production-coverage/packages/rust-std/pairs/package.json index b0fea514f..d5669b938 100644 --- a/tests/production-export/production-coverage/packages/rust-std/pairs/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/pairs/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"pairs","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"first","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"pairs","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":0}},{"kind":"first","value":{"kind":"var","name":0}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}}},"parameters":[0],"result":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"nat"}},"types":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/pairs/provenance.json b/tests/production-export/production-coverage/packages/rust-std/pairs/provenance.json index 8371e3508..e16be0bcb 100644 --- a/tests/production-export/production-coverage/packages/rust-std/pairs/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/pairs/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a3dd557c4339d106e7e177364f68702e05259c1cdf7bcc15c6c3801657acecac","src/lib.rs":"23479ab66c4b197434b8b1193fdb3ab0c4ad64e05eda32f3f34a6d2a117dc842"},"name":"pairs","profile":"rust-std","program":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"a3dd557c4339d106e7e177364f68702e05259c1cdf7bcc15c6c3801657acecac","src/lib.rs":"23479ab66c4b197434b8b1193fdb3ab0c4ad64e05eda32f3f34a6d2a117dc842"},"name":"pairs","profile":"rust-std","program":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/parity/package.json b/tests/production-export/production-coverage/packages/rust-std/parity/package.json index d773a4d48..217058b8d 100644 --- a/tests/production-export/production-coverage/packages/rust-std/parity/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/parity/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"parity","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"parity","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"zero"}},{"binders":[1],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/parity/provenance.json b/tests/production-export/production-coverage/packages/rust-std/parity/provenance.json index 38a9fc20b..0141e1425 100644 --- a/tests/production-export/production-coverage/packages/rust-std/parity/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/parity/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6eec599d19aab86b6e6c59ee909f6f5478461263e25000e7bc26f67766ef73df","src/lib.rs":"ee4df1540df0d5da7ff6c5b6892f04280f4e6353416665713ae22eb49034238e"},"name":"parity","profile":"rust-std","program":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"6eec599d19aab86b6e6c59ee909f6f5478461263e25000e7bc26f67766ef73df","src/lib.rs":"ee4df1540df0d5da7ff6c5b6892f04280f4e6353416665713ae22eb49034238e"},"name":"parity","profile":"rust-std","program":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/records/package.json b/tests/production-export/production-coverage/packages/rust-std/records/package.json index 8a4c1eb0a..632b39af8 100644 --- a/tests/production-export/production-coverage/packages/rust-std/records/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/records/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"records","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"function":1,"kind":"call","operands":[]}}],"operation":{"kind":"nat_add"}},{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":2}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"let","name":2,"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"parameters":[],"result":{"index":2,"kind":"adt"},"types":[]},{"body":{"index":0,"kind":"field","value":{"kind":"var","name":0}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"records","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]},{"constructors":[[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":2}},{"index":1,"kind":"field","value":{"function":1,"kind":"call","operands":[]}}],"operation":{"kind":"nat_add"}},{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"index":1,"kind":"field","value":{"kind":"var","name":2}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"bound":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"kind":"let","name":2,"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},"parameters":[],"result":{"index":2,"kind":"adt"},"types":[]},{"body":{"index":0,"kind":"field","value":{"kind":"var","name":0}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/records/provenance.json b/tests/production-export/production-coverage/packages/rust-std/records/provenance.json index ac0ef2eee..5a0c5e034 100644 --- a/tests/production-export/production-coverage/packages/rust-std/records/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/records/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75a1f2726772f72e4e3d6999f4a2e57d1b02c3dfada582fcf741f36a7e68aab8","src/lib.rs":"606a29cf73c0c31afe69443d0c19db59767e93145d66f86c8509216927a9893f"},"name":"records","profile":"rust-std","program":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"75a1f2726772f72e4e3d6999f4a2e57d1b02c3dfada582fcf741f36a7e68aab8","src/lib.rs":"606a29cf73c0c31afe69443d0c19db59767e93145d66f86c8509216927a9893f"},"name":"records","profile":"rust-std","program":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/rewrite/package.json b/tests/production-export/production-coverage/packages/rust-std/rewrite/package.json index 6d7f43114..ee4080cd5 100644 --- a/tests/production-export/production-coverage/packages/rust-std/rewrite/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/rewrite/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"rewrite","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"index":0,"kind":"adt"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[5,6],"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"build","operands":[{"kind":"var","name":6},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"index":0,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"arms":[{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[5,6],"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"index":0,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"rewrite","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}]]}],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"index":0,"kind":"adt"}}},"parameters":[0],"result":{"kind":"pair","left":{"index":0,"kind":"adt"},"right":{"index":0,"kind":"adt"}},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[5,6],"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"build","operands":[{"kind":"var","name":6},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"index":0,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"arms":[{"binders":[4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":3}]},"shape":{"constructor":0,"kind":"adt"}},{"binders":[5,6],"body":{"function":2,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":5},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":0,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":0,"kind":"adt"}},"parameters":[0],"result":{"index":0,"kind":"adt"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/rewrite/provenance.json b/tests/production-export/production-coverage/packages/rust-std/rewrite/provenance.json index eb4764f6b..783a2adcc 100644 --- a/tests/production-export/production-coverage/packages/rust-std/rewrite/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/rewrite/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"385a04bfd361768612fff077142ae59ca5552088bdc4df6d2c920d7079d5b569","src/lib.rs":"b5db01a7608d311f4b632fa5cc1d0bfacd05b2be85c939bf570ade65ba6b66b7"},"name":"rewrite","profile":"rust-std","program":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"385a04bfd361768612fff077142ae59ca5552088bdc4df6d2c920d7079d5b569","src/lib.rs":"b5db01a7608d311f4b632fa5cc1d0bfacd05b2be85c939bf570ade65ba6b66b7"},"name":"rewrite","profile":"rust-std","program":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/rose_total/package.json b/tests/production-export/production-coverage/packages/rust-std/rose_total/package.json index f37ca0074..7e15c7c22 100644 --- a/tests/production-export/production-coverage/packages/rust-std/rose_total/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/rose_total/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"rose_total","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[1,2],"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":0,"kind":"adt"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"rose_total","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"},{"element":{"index":0,"kind":"adt"},"kind":"list"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"index":0,"kind":"adt"},"kind":"list"}}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[1,2],"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":0,"kind":"adt"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/rose_total/provenance.json b/tests/production-export/production-coverage/packages/rust-std/rose_total/provenance.json index f7ed98f61..7cc4132c7 100644 --- a/tests/production-export/production-coverage/packages/rust-std/rose_total/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/rose_total/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c0dc72188af676095b448d956e1239b374cac42b1af2de7e858291cbf5383863","src/lib.rs":"eb06a93dae2396dc20bd68830ea3f1742d699edfbbd07eac4dcd62ce7ee7db6d"},"name":"rose_total","profile":"rust-std","program":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"c0dc72188af676095b448d956e1239b374cac42b1af2de7e858291cbf5383863","src/lib.rs":"eb06a93dae2396dc20bd68830ea3f1742d699edfbbd07eac4dcd62ce7ee7db6d"},"name":"rose_total","profile":"rust-std","program":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/sequences/package.json b/tests/production-export/production-coverage/packages/rust-std/sequences/package.json index ae2aa68ee..4fef81153 100644 --- a/tests/production-export/production-coverage/packages/rust-std/sequences/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/sequences/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"sequences","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a","kind":"bytes"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own","own"]}],"name":"sequences","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0a","kind":"bytes"}}],"operation":{"kind":"append"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"index"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}],"operation":{"kind":"slice"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}}],"operation":{"kind":"equal"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"equal"}},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"operation":{"kind":"equal"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"nat"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"nat"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"bytes"}},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"bool"}}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/sequences/provenance.json b/tests/production-export/production-coverage/packages/rust-std/sequences/provenance.json index adff30c4f..f93d014a1 100644 --- a/tests/production-export/production-coverage/packages/rust-std/sequences/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/sequences/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aa7298676d2c7b758270edff2ce45121c53239621d97fb162008201032ddfdeb","src/lib.rs":"8bd41d630b6aba27bb4e3ac28bf351ce079193639a4a6de2270bd0b3f63714f9"},"name":"sequences","profile":"rust-std","program":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aa7298676d2c7b758270edff2ce45121c53239621d97fb162008201032ddfdeb","src/lib.rs":"8bd41d630b6aba27bb4e3ac28bf351ce079193639a4a6de2270bd0b3f63714f9"},"name":"sequences","profile":"rust-std","program":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/set_ops/package.json b/tests/production-export/production-coverage/packages/rust-std/set_ops/package.json index a8f0d0efc..596ad554c 100644 --- a/tests/production-export/production-coverage/packages/rust-std/set_ops/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/set_ops/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":11,"name":"run","parameters":["own","own","own"]}],"name":"set_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":4,"kind":"call","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":11,"name":"run","parameters":["own","own","own"]}],"name":"set_ops","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":0}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":1,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":2,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":4,"kind":"call","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"nat"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"function":9,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"nat"},"kind":"list"}},"kind":"cond","then_branch":{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"nat"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"nat"},"kind":"list"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":10,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"bool"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"element":{"kind":"nat"},"kind":"list"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"nat"},"kind":"list"}}}}}}}}},"types":[{"element":{"kind":"nat"},"kind":"list"},{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/set_ops/provenance.json b/tests/production-export/production-coverage/packages/rust-std/set_ops/provenance.json index 8b273ee83..eceae4325 100644 --- a/tests/production-export/production-coverage/packages/rust-std/set_ops/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/set_ops/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":11,"name":"run"}],"files":{"Cargo.toml":"9cef623c27ac72b79e5d3195d80b594d76fe1a759d11955b293aa0332d7e27c9","src/lib.rs":"4ee0aced9c00e80999f82926c6c5479cb207c9f302457058066a7c59561f8be0"},"name":"set_ops","profile":"rust-std","program":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":11,"name":"run"}],"files":{"Cargo.toml":"9cef623c27ac72b79e5d3195d80b594d76fe1a759d11955b293aa0332d7e27c9","src/lib.rs":"4ee0aced9c00e80999f82926c6c5479cb207c9f302457058066a7c59561f8be0"},"name":"set_ops","profile":"rust-std","program":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/shapes/package.json b/tests/production-export/production-coverage/packages/rust-std/shapes/package.json index d3ac7bc7a..85dd9a88d 100644 --- a/tests/production-export/production-coverage/packages/rust-std/shapes/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/shapes/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shapes","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}],[]]}],"functions":[{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shapes","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}],[]]}],"functions":[{"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},{"function":1,"kind":"call","operands":[{"kind":"build","operands":[],"shape":{"constructor":2,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/shapes/provenance.json b/tests/production-export/production-coverage/packages/rust-std/shapes/provenance.json index fab0a55a0..cb6e1e348 100644 --- a/tests/production-export/production-coverage/packages/rust-std/shapes/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/shapes/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f2da6540473eb8c30328ec5522a3a0d931e34392c6720ac9842e96878fa8fd5","src/lib.rs":"b91119bec609c3dc5e31503329b9427d2589ee8baa289f5b2a14301fc2d685e5"},"name":"shapes","profile":"rust-std","program":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"9f2da6540473eb8c30328ec5522a3a0d931e34392c6720ac9842e96878fa8fd5","src/lib.rs":"b91119bec609c3dc5e31503329b9427d2589ee8baa289f5b2a14301fc2d685e5"},"name":"shapes","profile":"rust-std","program":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/string_graph/package.json b/tests/production-export/production-coverage/packages/rust-std/string_graph/package.json index afa973815..dd1c19c83 100644 --- a/tests/production-export/production-coverage/packages/rust-std/string_graph/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/string_graph/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":15,"name":"run","parameters":["own"]}],"name":"string_graph","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":14,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":13,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":14,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"string"},"kind":"list"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":15,"name":"run","parameters":["own"]}],"name":"string_graph","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"bound":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"kind":"let","name":1,"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"zero"}},{"binders":[6],"body":{"arms":[{"binders":[],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[7,8],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[9,10],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":6},{"function":12,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":9}]},{"kind":"build","operands":[{"kind":"var","name":9},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"parameters":[0,1,2,3],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"nat"},{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":1}]},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":3},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"function":11,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},{"kind":"var","name":1}]},"else_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":3},{"function":7,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}]}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"function":7,"kind":"call","operands":[{"kind":"var","name":3},{"function":8,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"element":{"kind":"string"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":8,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"none"}},{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"second","value":{"kind":"var","name":2}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":10,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"first","value":{"kind":"var","name":2}}],"operation":{"kind":"compare"}},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"arms":[{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"var","name":3},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"function":12,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":1}]}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"compare"}},"type":{"element":{"kind":"string"},"kind":"list"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"string"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"string"},"kind":"list"},"types":[{"element":{"kind":"string"},"kind":"list"},{"kind":"string"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"condition":{"function":14,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":13,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"lt"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"eq"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"gt"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"compare"}},"type":{"kind":"bool"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"function":14,"kind":"call","operands":[{"kind":"var","name":2}]}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"bool"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"element":{"kind":"string"},"kind":"list"}]},{"body":{"condition":{"function":13,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":0,"kind":"call","operands":[{"kind":"var","name":0}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}}},"types":[{"element":{"kind":"pair","left":{"kind":"string"},"right":{"element":{"kind":"string"},"kind":"list"}},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/string_graph/provenance.json b/tests/production-export/production-coverage/packages/rust-std/string_graph/provenance.json index 2ac6ee2ce..14c785f0b 100644 --- a/tests/production-export/production-coverage/packages/rust-std/string_graph/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/string_graph/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":15,"name":"run"}],"files":{"Cargo.toml":"8309d0c12333a77366606152fa5e7fe1e3557cbadf25b7bb1c65141f372c670f","src/lib.rs":"39b5a659c4e5b22ffb198a522eadd0c384d9c68b778d62c00d6acd3a406b10b2"},"name":"string_graph","profile":"rust-std","program":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":15,"name":"run"}],"files":{"Cargo.toml":"8309d0c12333a77366606152fa5e7fe1e3557cbadf25b7bb1c65141f372c670f","src/lib.rs":"39b5a659c4e5b22ffb198a522eadd0c384d9c68b778d62c00d6acd3a406b10b2"},"name":"string_graph","profile":"rust-std","program":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/syntax_total/package.json b/tests/production-export/production-coverage/packages/rust-std/syntax_total/package.json index 80e7635c5..c1c575ad1 100644 --- a/tests/production-export/production-coverage/packages/rust-std/syntax_total/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/syntax_total/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"syntax_total","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"string"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":1,"kind":"adt"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":4}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[3,4],"body":{"kind":"prim","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":4}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"syntax_total","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"index":0,"kind":"adt"},{"index":0,"kind":"adt"}],[{"element":{"index":1,"kind":"adt"},"kind":"list"},{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"string"},{"index":0,"kind":"adt"}],[{"index":1,"kind":"adt"},{"index":1,"kind":"adt"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[4,5],"body":{"kind":"prim","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":4}]},{"function":1,"kind":"call","operands":[{"kind":"var","name":5}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":2,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":1}]},{"function":2,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":1,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[1,2],"body":{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[3,4],"body":{"kind":"prim","operands":[{"function":3,"kind":"call","operands":[{"kind":"var","name":3}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":4}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":1,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/syntax_total/provenance.json b/tests/production-export/production-coverage/packages/rust-std/syntax_total/provenance.json index 6dfad4be6..fbd84b4dd 100644 --- a/tests/production-export/production-coverage/packages/rust-std/syntax_total/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/syntax_total/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3af3d260c8a7a536d3b4356bf86216ede694c8c1a9c668e89673e25e9e784112","src/lib.rs":"4eff2069f487785324288a06eac2ec67807eeef02564e7b6796656aa84f6f349"},"name":"syntax_total","profile":"rust-std","program":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3af3d260c8a7a536d3b4356bf86216ede694c8c1a9c668e89673e25e9e784112","src/lib.rs":"4eff2069f487785324288a06eac2ec67807eeef02564e7b6796656aa84f6f349"},"name":"syntax_total","profile":"rust-std","program":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/text/package.json b/tests/production-export/production-coverage/packages/rust-std/text/package.json index 5dead56d4..2947161ec 100644 --- a/tests/production-export/production-coverage/packages/rust-std/text/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/text/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"text","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"x\"y"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"var","name":1}],"operation":{"kind":"join"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":2}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"utf8_encode"}},"kind":"let","name":2,"type":{"kind":"bytes"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"string"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"text","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"utf8_decode"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00ff","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u32"},"value":{"kind":"u32","value":"4"}}],"operation":{"kind":"split_exact"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"x\"y"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"string"},"kind":"list"}},{"kind":"var","name":1}],"operation":{"kind":"join"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":2}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"utf8_encode"}},"kind":"let","name":2,"type":{"kind":"bytes"}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"pair","left":{"kind":"option","value":{"kind":"string"}},"right":{"kind":"pair","left":{"kind":"ordering"},"right":{"kind":"pair","left":{"kind":"option","value":{"element":{"kind":"string"},"kind":"list"}},"right":{"kind":"pair","left":{"kind":"string"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}}}}}},"types":[{"kind":"string"},{"kind":"string"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/text/provenance.json b/tests/production-export/production-coverage/packages/rust-std/text/provenance.json index 454da823b..33431e788 100644 --- a/tests/production-export/production-coverage/packages/rust-std/text/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/text/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"85db331d2126ced03d3a6263139dbbca63768a36da3535c353c177a56d64ee63","src/lib.rs":"b05d4565bd2dc0d31ae405d3fb2a6e9f04e34d04b88b72eb6ca8d0e55fca832b"},"name":"text","profile":"rust-std","program":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"85db331d2126ced03d3a6263139dbbca63768a36da3535c353c177a56d64ee63","src/lib.rs":"b05d4565bd2dc0d31ae405d3fb2a6e9f04e34d04b88b72eb6ca8d0e55fca832b"},"name":"text","profile":"rust-std","program":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/tree_total/package.json b/tests/production-export/production-coverage/packages/rust-std/tree_total/package.json index 5c55589ed..9bffa5d18 100644 --- a/tests/production-export/production-coverage/packages/rust-std/tree_total/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/tree_total/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"tree_total","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"index":0,"kind":"adt"},{"kind":"nat"},{"index":0,"kind":"adt"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[1,2,3],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"tree_total","profile":"rust-std","program":{"adts":[{"constructors":[[],[{"index":0,"kind":"adt"},{"kind":"nat"},{"index":0,"kind":"adt"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"5"}},{"kind":"build","operands":[],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[1,2,3],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":1}]},{"kind":"var","name":2}],"operation":{"kind":"nat_add"}},{"function":1,"kind":"call","operands":[{"kind":"var","name":3}]}],"operation":{"kind":"nat_add"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/tree_total/provenance.json b/tests/production-export/production-coverage/packages/rust-std/tree_total/provenance.json index c5d674bc3..9f4e171a0 100644 --- a/tests/production-export/production-coverage/packages/rust-std/tree_total/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/tree_total/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ae25e88a1e094fbdd0952114f0621e20767e9394b73815fcd4da238711b33c78","src/lib.rs":"58120ca1ac6217d63c5969d6f5314d526b4b340e11d5dc6886af1f2296b33375"},"name":"tree_total","profile":"rust-std","program":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ae25e88a1e094fbdd0952114f0621e20767e9394b73815fcd4da238711b33c78","src/lib.rs":"58120ca1ac6217d63c5969d6f5314d526b4b340e11d5dc6886af1f2296b33375"},"name":"tree_total","profile":"rust-std","program":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/well_founded/package.json b/tests/production-export/production-coverage/packages/rust-std/well_founded/package.json index c7cf8893a..8c7872836 100644 --- a/tests/production-export/production-coverage/packages/rust-std/well_founded/package.json +++ b/tests/production-export/production-coverage/packages/rust-std/well_founded/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"well_founded","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":2,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"var","name":0}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}]},"kind":"cond","then_branch":{"kind":"var","name":1}}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"well_founded","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"build","operands":[{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},{"kind":"build","operands":[{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":2,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":1}]},"kind":"cond","then_branch":{"kind":"var","name":0}},"kind":"cond","then_branch":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_le"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}]},"kind":"cond","then_branch":{"kind":"var","name":1}}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production-coverage/packages/rust-std/well_founded/provenance.json b/tests/production-export/production-coverage/packages/rust-std/well_founded/provenance.json index 990769276..7542ca768 100644 --- a/tests/production-export/production-coverage/packages/rust-std/well_founded/provenance.json +++ b/tests/production-export/production-coverage/packages/rust-std/well_founded/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0c780ccff965ccc10faa78b2714b324aa2f72bb88aedc1f0632079faded0b0d8","src/lib.rs":"f7b88a805108f63fc65b351432801b4521e37655461926bc3f6b254896d38e62"},"name":"well_founded","profile":"rust-std","program":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f3572b43e36d5c62b7601d32507ebc3a788577fc4d0c7169b88b91dd52b57ddd"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0c780ccff965ccc10faa78b2714b324aa2f72bb88aedc1f0632079faded0b0d8","src/lib.rs":"f7b88a805108f63fc65b351432801b4521e37655461926bc3f6b254896d38e62"},"name":"well_founded","profile":"rust-std","program":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["e05bf7cb47aac48ea11c4a7ac75c79629a9a4e141d82abe0f652f6e6717009ef"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/checked_sum/package.json b/tests/production-export/production/packages/rust-core/checked_sum/package.json index d844fbb12..a7461cdcf 100644 --- a/tests/production-export/production/packages/rust-core/checked_sum/package.json +++ b/tests/production-export/production/packages/rust-core/checked_sum/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"checked_sum","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"checked_sum","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/checked_sum/provenance.json b/tests/production-export/production/packages/rust-core/checked_sum/provenance.json index 101bd7918..ad015d152 100644 --- a/tests/production-export/production/packages/rust-core/checked_sum/provenance.json +++ b/tests/production-export/production/packages/rust-core/checked_sum/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d2642abd4556782d8a017a0a6b2cfb4bdec3858040ce0f535f3a44d5dcf9de6a","src/lib.rs":"9b5570739b12d66a09de99dcdadc4cd439838b21c543e654417a6dba78f0aba6"},"name":"checked_sum","profile":"rust-core","program":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d2642abd4556782d8a017a0a6b2cfb4bdec3858040ce0f535f3a44d5dcf9de6a","src/lib.rs":"9b5570739b12d66a09de99dcdadc4cd439838b21c543e654417a6dba78f0aba6"},"name":"checked_sum","profile":"rust-core","program":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/halvings/package.json b/tests/production-export/production/packages/rust-core/halvings/package.json index 61eda1d7f..3dc9fe4d9 100644 --- a/tests/production-export/production/packages/rust-core/halvings/package.json +++ b/tests/production-export/production/packages/rust-core/halvings/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"halvings","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"halvings","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/halvings/provenance.json b/tests/production-export/production/packages/rust-core/halvings/provenance.json index d602678a8..add071c31 100644 --- a/tests/production-export/production/packages/rust-core/halvings/provenance.json +++ b/tests/production-export/production/packages/rust-core/halvings/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5ce9a4750afc2319c429f0c99580235916a3572af40fc079449063d4d7d64b9d","src/lib.rs":"db9a71f74e30ecb581b7ac2688e7277d0b6c2dc369925b1ccf67223b0967ccd6"},"name":"halvings","profile":"rust-core","program":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5ce9a4750afc2319c429f0c99580235916a3572af40fc079449063d4d7d64b9d","src/lib.rs":"db9a71f74e30ecb581b7ac2688e7277d0b6c2dc369925b1ccf67223b0967ccd6"},"name":"halvings","profile":"rust-core","program":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/quadruple/package.json b/tests/production-export/production/packages/rust-core/quadruple/package.json index 12b2a4547..6a704e02c 100644 --- a/tests/production-export/production/packages/rust-core/quadruple/package.json +++ b/tests/production-export/production/packages/rust-core/quadruple/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"quadruple","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"quadruple","profile":"rust-core","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/quadruple/provenance.json b/tests/production-export/production/packages/rust-core/quadruple/provenance.json index 2044d836f..a165195cf 100644 --- a/tests/production-export/production/packages/rust-core/quadruple/provenance.json +++ b/tests/production-export/production/packages/rust-core/quadruple/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce430c8cfa11725511655d377de19ff244bde5bf904cda9aa11454e0d20da660","src/lib.rs":"efcdcd2e203664aa67d6f9b0a87984c6e9b12f248be84c1b7299e334561b261a"},"name":"quadruple","profile":"rust-core","program":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce430c8cfa11725511655d377de19ff244bde5bf904cda9aa11454e0d20da660","src/lib.rs":"efcdcd2e203664aa67d6f9b0a87984c6e9b12f248be84c1b7299e334561b261a"},"name":"quadruple","profile":"rust-core","program":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/shape_area/package.json b/tests/production-export/production/packages/rust-core/shape_area/package.json index deab4d243..b99d5b850 100644 --- a/tests/production-export/production/packages/rust-core/shape_area/package.json +++ b/tests/production-export/production/packages/rust-core/shape_area/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shape_area","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shape_area","profile":"rust-core","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-core/shape_area/provenance.json b/tests/production-export/production/packages/rust-core/shape_area/provenance.json index b15ec18d4..17f411222 100644 --- a/tests/production-export/production/packages/rust-core/shape_area/provenance.json +++ b/tests/production-export/production/packages/rust-core/shape_area/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"683aa9bf20d061b2173baf56bc15458181e14c259970edff7f60eb310b93df8f","src/lib.rs":"d9fb377859859c89d489754c8138f5b238157b6f75bda86fdce267925e10732c"},"name":"shape_area","profile":"rust-core","program":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"683aa9bf20d061b2173baf56bc15458181e14c259970edff7f60eb310b93df8f","src/lib.rs":"d9fb377859859c89d489754c8138f5b238157b6f75bda86fdce267925e10732c"},"name":"shape_area","profile":"rust-core","program":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215","runtime":"7f18f40838cbf5b74494efecbd3553c16cd6b0fb42445bdff4c8036b5f0e2a95","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/checked_sum/package.json b/tests/production-export/production/packages/rust-std/checked_sum/package.json index cafd2e228..048902430 100644 --- a/tests/production-export/production/packages/rust-std/checked_sum/package.json +++ b/tests/production-export/production/packages/rust-std/checked_sum/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"checked_sum","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"checked_sum","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_add"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u32"}},"types":[{"kind":"fixed","width":"u32"},{"kind":"fixed","width":"u32"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/checked_sum/provenance.json b/tests/production-export/production/packages/rust-std/checked_sum/provenance.json index 3ce88509a..1310f67be 100644 --- a/tests/production-export/production/packages/rust-std/checked_sum/provenance.json +++ b/tests/production-export/production/packages/rust-std/checked_sum/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d2642abd4556782d8a017a0a6b2cfb4bdec3858040ce0f535f3a44d5dcf9de6a","src/lib.rs":"aaaaf1ccf07f5112e0f7a16fc65b21ab9c58c9341844fe6882f82a151037da53"},"name":"checked_sum","profile":"rust-std","program":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"d2642abd4556782d8a017a0a6b2cfb4bdec3858040ce0f535f3a44d5dcf9de6a","src/lib.rs":"aaaaf1ccf07f5112e0f7a16fc65b21ab9c58c9341844fe6882f82a151037da53"},"name":"checked_sum","profile":"rust-std","program":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/halvings/package.json b/tests/production-export/production/packages/rust-std/halvings/package.json index b03c1d683..04740c237 100644 --- a/tests/production-export/production/packages/rust-std/halvings/package.json +++ b/tests/production-export/production/packages/rust-std/halvings/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"halvings","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"halvings","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":1,"kind":"call","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}]},"kind":"cond","then_branch":{"kind":"var","name":1}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/halvings/provenance.json b/tests/production-export/production/packages/rust-std/halvings/provenance.json index 8ca733a97..be630732b 100644 --- a/tests/production-export/production/packages/rust-std/halvings/provenance.json +++ b/tests/production-export/production/packages/rust-std/halvings/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5ce9a4750afc2319c429f0c99580235916a3572af40fc079449063d4d7d64b9d","src/lib.rs":"653fb4583c2029804d083e8fb442ae21ed22c459d356a1161f3919d889d17c27"},"name":"halvings","profile":"rust-std","program":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5ce9a4750afc2319c429f0c99580235916a3572af40fc079449063d4d7d64b9d","src/lib.rs":"653fb4583c2029804d083e8fb442ae21ed22c459d356a1161f3919d889d17c27"},"name":"halvings","profile":"rust-std","program":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/head_or/package.json b/tests/production-export/production/packages/rust-std/head_or/package.json index 399958d08..7631bc975 100644 --- a/tests/production-export/production/packages/rust-std/head_or/package.json +++ b/tests/production-export/production/packages/rust-std/head_or/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"head_or","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"var","name":2},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own"]}],"name":"head_or","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"kind":"var","name":2},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/head_or/provenance.json b/tests/production-export/production/packages/rust-std/head_or/provenance.json index ce9e993ee..1021fd4dd 100644 --- a/tests/production-export/production/packages/rust-std/head_or/provenance.json +++ b/tests/production-export/production/packages/rust-std/head_or/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f724063bb6df92304f518e824a184b89f9956e15421cffbd5d158d5d9f8092c4","src/lib.rs":"9eaf875ce4a10119c0e49f42e27fdc00b2a765df8dfaafca61f6ac06cc5f679f"},"name":"head_or","profile":"rust-std","program":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"f724063bb6df92304f518e824a184b89f9956e15421cffbd5d158d5d9f8092c4","src/lib.rs":"9eaf875ce4a10119c0e49f42e27fdc00b2a765df8dfaafca61f6ac06cc5f679f"},"name":"head_or","profile":"rust-std","program":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/quadruple/package.json b/tests/production-export/production/packages/rust-std/quadruple/package.json index e24c2bb95..e34d6da24 100644 --- a/tests/production-export/production/packages/rust-std/quadruple/package.json +++ b/tests/production-export/production/packages/rust-std/quadruple/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"quadruple","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"quadruple","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"captures":[],"function":2,"kind":"closure"},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]},{"body":{"kind":"apply","operands":[{"kind":"apply","operands":[{"kind":"var","name":1}],"target":{"kind":"var","name":0}}],"target":{"kind":"var","name":0}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"nat"}},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":0}],"operation":{"kind":"nat_add"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/quadruple/provenance.json b/tests/production-export/production/packages/rust-std/quadruple/provenance.json index aa73e235f..b6dff1c69 100644 --- a/tests/production-export/production/packages/rust-std/quadruple/provenance.json +++ b/tests/production-export/production/packages/rust-std/quadruple/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce430c8cfa11725511655d377de19ff244bde5bf904cda9aa11454e0d20da660","src/lib.rs":"e651d8ffeb9f1ca328081a4bb63c81f67d0cab0869aeae101c9797ff0fead067"},"name":"quadruple","profile":"rust-std","program":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"ce430c8cfa11725511655d377de19ff244bde5bf904cda9aa11454e0d20da660","src/lib.rs":"e651d8ffeb9f1ca328081a4bb63c81f67d0cab0869aeae101c9797ff0fead067"},"name":"quadruple","profile":"rust-std","program":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/shape_area/package.json b/tests/production-export/production/packages/rust-std/shape_area/package.json index ebe6771a7..80b0f8ca8 100644 --- a/tests/production-export/production/packages/rust-std/shape_area/package.json +++ b/tests/production-export/production/packages/rust-std/shape_area/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shape_area","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"shape_area","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"nat"}],[{"kind":"nat"},{"kind":"nat"}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":0,"kind":"adt"}}]},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":1}],"operation":{"kind":"nat_mul"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":0,"kind":"adt"}},{"binders":[2,3],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_mul"}},"shape":{"constructor":1,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"index":0,"kind":"adt"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/shape_area/provenance.json b/tests/production-export/production/packages/rust-std/shape_area/provenance.json index 4acda100f..26693594a 100644 --- a/tests/production-export/production/packages/rust-std/shape_area/provenance.json +++ b/tests/production-export/production/packages/rust-std/shape_area/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"683aa9bf20d061b2173baf56bc15458181e14c259970edff7f60eb310b93df8f","src/lib.rs":"8cf6fe537cdc43e608ce442810740bf54926dc3eda403ba551e2d958285b5a4e"},"name":"shape_area","profile":"rust-std","program":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"683aa9bf20d061b2173baf56bc15458181e14c259970edff7f60eb310b93df8f","src/lib.rs":"8cf6fe537cdc43e608ce442810740bf54926dc3eda403ba551e2d958285b5a4e"},"name":"shape_area","profile":"rust-std","program":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/sum_all/package.json b/tests/production-export/production/packages/rust-std/sum_all/package.json index 891eefbd1..e7baeb608 100644 --- a/tests/production-export/production/packages/rust-std/sum_all/package.json +++ b/tests/production-export/production/packages/rust-std/sum_all/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_all","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"sum_all","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"prim","operands":[{"kind":"var","name":1},{"function":1,"kind":"call","operands":[{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"nat"},"kind":"list"}]}],"spec":"lexlean/target-program/1"},"sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/production/packages/rust-std/sum_all/provenance.json b/tests/production-export/production/packages/rust-std/sum_all/provenance.json index e9d7398b0..6060100eb 100644 --- a/tests/production-export/production/packages/rust-std/sum_all/provenance.json +++ b/tests/production-export/production/packages/rust-std/sum_all/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b927ff521f32d7fb2292ab2d020df8a2e1acd30460ac58429f4292741a2f51d3","src/lib.rs":"d05d8af8bf9f349f05081d5a7563edaaf5617159fdf4e463335b2a82070222ef"},"name":"sum_all","profile":"rust-std","program":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["ecf58505f4e2844618eff0bdc9a2ce9dcf5d0a65b1a68627116a7fd4d4a29a8b"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"b927ff521f32d7fb2292ab2d020df8a2e1acd30460ac58429f4292741a2f51d3","src/lib.rs":"d05d8af8bf9f349f05081d5a7563edaaf5617159fdf4e463335b2a82070222ef"},"name":"sum_all","profile":"rust-std","program":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f5a58e441acc8b93ded11826c51cc7c8399ec177e079787a9b6551789ce1cab8"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/ends_with/package.json b/tests/production-export/stdlib/packages/rust-std/ends_with/package.json index 361cf97b8..a647871da 100644 --- a/tests/production-export/stdlib/packages/rust-std/ends_with/package.json +++ b/tests/production-export/stdlib/packages/rust-std/ends_with/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"ends_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"ends_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/ends_with/provenance.json b/tests/production-export/stdlib/packages/rust-std/ends_with/provenance.json index 2e8abc451..4813a126e 100644 --- a/tests/production-export/stdlib/packages/rust-std/ends_with/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/ends_with/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aca215ca66dbd07b695aea352c855408398f391b7feba3baad37388c4e77bb3c","src/lib.rs":"7b5c3234b40c3d7ed26a091c4bca20a8411137d22ba5dd61148ec9e7ae6e153c"},"name":"ends_with","profile":"rust-std","program":"2e8cee85b376065a6078160fa53fd52c7a2f6aa31eb349462fb499ef41683e7f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"aca215ca66dbd07b695aea352c855408398f391b7feba3baad37388c4e77bb3c","src/lib.rs":"7b5c3234b40c3d7ed26a091c4bca20a8411137d22ba5dd61148ec9e7ae6e153c"},"name":"ends_with","profile":"rust-std","program":"2e8cee85b376065a6078160fa53fd52c7a2f6aa31eb349462fb499ef41683e7f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/find/package.json b/tests/production-export/stdlib/packages/rust-std/find/package.json index e6a6d4c95..0757efff1 100644 --- a/tests/production-export/stdlib/packages/rust-std/find/package.json +++ b/tests/production-export/stdlib/packages/rust-std/find/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"find","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":3},{"kind":"var","name":0},{"kind":"var","name":2}],"function":2,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":0},{"kind":"var","name":4}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2,3,4],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"find","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":3},{"kind":"var","name":0},{"kind":"var","name":2}],"function":2,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"function":3,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":0},{"kind":"var","name":4}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2,3,4],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/find/provenance.json b/tests/production-export/stdlib/packages/rust-std/find/provenance.json index 668236a7b..b79076298 100644 --- a/tests/production-export/stdlib/packages/rust-std/find/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/find/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"65b8766beaad3445a34057c23351f9454db56cef4c61b2bdb18735c4f186f1d4","src/lib.rs":"457794cebfb5131f4e57731a77bbff0259d7a15f1860c012d6898cd1c104d310"},"name":"find","profile":"rust-std","program":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"65b8766beaad3445a34057c23351f9454db56cef4c61b2bdb18735c4f186f1d4","src/lib.rs":"457794cebfb5131f4e57731a77bbff0259d7a15f1860c012d6898cd1c104d310"},"name":"find","profile":"rust-std","program":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/join_with/package.json b/tests/production-export/stdlib/packages/rust-std/join_with/package.json index bb505c6e5..df4fd0b70 100644 --- a/tests/production-export/stdlib/packages/rust-std/join_with/package.json +++ b/tests/production-export/stdlib/packages/rust-std/join_with/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"join_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},{"kind":"var","name":0}]},"type":{"kind":"bytes"}},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"fn","parameters":[{"kind":"option","value":{"kind":"bytes"}},{"kind":"bytes"}],"result":{"kind":"option","value":{"kind":"bytes"}}},{"kind":"option","value":{"kind":"bytes"}},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":0}],"operation":{"kind":"append"}},{"kind":"var","name":2}],"operation":{"kind":"append"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"join_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":2},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1}],"function":2,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},{"kind":"var","name":0}]},"type":{"kind":"bytes"}},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"fn","parameters":[{"kind":"option","value":{"kind":"bytes"}},{"kind":"bytes"}],"result":{"kind":"option","value":{"kind":"bytes"}}},{"kind":"option","value":{"kind":"bytes"}},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}},{"binders":[3],"body":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":0}],"operation":{"kind":"append"}},{"kind":"var","name":2}],"operation":{"kind":"append"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/join_with/provenance.json b/tests/production-export/stdlib/packages/rust-std/join_with/provenance.json index 0a46809e7..7a03b5518 100644 --- a/tests/production-export/stdlib/packages/rust-std/join_with/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/join_with/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5b8c1edac95e10481210f741989077b0b33bafb42f71c257d0baa28de2931790","src/lib.rs":"53ca1a20dd060557588c5f5676af74172b47b5f34873ee25bf20efbb5ca85d33"},"name":"join_with","profile":"rust-std","program":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5b8c1edac95e10481210f741989077b0b33bafb42f71c257d0baa28de2931790","src/lib.rs":"53ca1a20dd060557588c5f5676af74172b47b5f34873ee25bf20efbb5ca85d33"},"name":"join_with","profile":"rust-std","program":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/lines/package.json b/tests/production-export/stdlib/packages/rust-std/lines/package.json index 9e1b17f30..958278b32 100644 --- a/tests/production-export/stdlib/packages/rust-std/lines/package.json +++ b/tests/production-export/stdlib/packages/rust-std/lines/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"lines","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":4}]},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":2,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":6,"kind":"call","operands":[{"captures":[],"function":7,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":5},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":9,"kind":"call","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0d","kind":"bytes"}}]},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"lines","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":3,"kind":"call","operands":[{"kind":"var","name":4}]},"kind":"cond","then_branch":{"function":3,"kind":"call","operands":[{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":2,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":6,"kind":"call","operands":[{"captures":[],"function":7,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":5},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":9,"kind":"call","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":10,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0d","kind":"bytes"}}]},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/lines/provenance.json b/tests/production-export/stdlib/packages/rust-std/lines/provenance.json index 97c32006a..3e029e55b 100644 --- a/tests/production-export/stdlib/packages/rust-std/lines/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/lines/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8784e433d55c1014c3ef57c25eb97e52b822f442912c6afef13bec448b09bbc4","src/lib.rs":"3464baef6c8989e7f3ef0440082437927fdc5bf55b7b334222d8bacdceae80c5"},"name":"lines","profile":"rust-std","program":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8784e433d55c1014c3ef57c25eb97e52b822f442912c6afef13bec448b09bbc4","src/lib.rs":"3464baef6c8989e7f3ef0440082437927fdc5bf55b7b334222d8bacdceae80c5"},"name":"lines","profile":"rust-std","program":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/split_on/package.json b/tests/production-export/stdlib/packages/rust-std/split_on/package.json index b973dcf53..1ae63300e 100644 --- a/tests/production-export/stdlib/packages/rust-std/split_on/package.json +++ b/tests/production-export/stdlib/packages/rust-std/split_on/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"split_on","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"function":3,"kind":"call","operands":[{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":3}}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":3}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":3,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":6,"kind":"call","operands":[{"captures":[],"function":7,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[6],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"var","name":5}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":5,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"split_on","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"body":{"function":3,"kind":"call","operands":[{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":3}}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":3}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":3,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":5,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":6,"kind":"call","operands":[{"captures":[],"function":7,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[6],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"var","name":5}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":5,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":6,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/split_on/provenance.json b/tests/production-export/stdlib/packages/rust-std/split_on/provenance.json index 9ae8363de..9ca756b3f 100644 --- a/tests/production-export/stdlib/packages/rust-std/split_on/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/split_on/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eec87b90321a716e390db4002e4dfdaa697e6daf4b86d7a2cd07c5f2ac707e2d","src/lib.rs":"d655f10225cbcf659140129f15911ebea1005006b91b542910504454c8155455"},"name":"split_on","profile":"rust-std","program":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eec87b90321a716e390db4002e4dfdaa697e6daf4b86d7a2cd07c5f2ac707e2d","src/lib.rs":"d655f10225cbcf659140129f15911ebea1005006b91b542910504454c8155455"},"name":"split_on","profile":"rust-std","program":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/starts_with/package.json b/tests/production-export/stdlib/packages/rust-std/starts_with/package.json index 485173f22..17d1192fc 100644 --- a/tests/production-export/stdlib/packages/rust-std/starts_with/package.json +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/package.json @@ -1 +1 @@ -{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"starts_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[2],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"none","function":0,"name":"run","parameters":["own","own"]}],"name":"starts_with","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"arms":[{"binders":[2],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/starts_with/provenance.json b/tests/production-export/stdlib/packages/rust-std/starts_with/provenance.json index 882f5cd3f..135d3a5d2 100644 --- a/tests/production-export/stdlib/packages/rust-std/starts_with/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0560bbd795b0d18aa5e54a6e850d5ba891a72eed60586ffd18ba3818a9f06400","src/lib.rs":"e41016d01141f5539ac77f084f9fc0a489ee13b13edf01649d8a018bb2ed968f"},"name":"starts_with","profile":"rust-std","program":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0560bbd795b0d18aa5e54a6e850d5ba891a72eed60586ffd18ba3818a9f06400","src/lib.rs":"e41016d01141f5539ac77f084f9fc0a489ee13b13edf01649d8a018bb2ed968f"},"name":"starts_with","profile":"rust-std","program":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/trim/package.json b/tests/production-export/stdlib/packages/rust-std/trim/package.json index 2f5b8a297..2df6d55d4 100644 --- a/tests/production-export/stdlib/packages/rust-std/trim/package.json +++ b/tests/production-export/stdlib/packages/rust-std/trim/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"trim","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_sub"}}]},"bound":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":4,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":5,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":4,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":6,"kind":"closure"},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"32"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"9"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"12"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"13"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]}],"spec":"lexlean/target-program/1"},"sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"trim","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"body":{"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"nat_sub"}}]},"bound":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"function":1,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":4,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":5,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":4,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":6,"kind":"closure"},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"function":9,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"32"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"9"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"12"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"13"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]}],"spec":"lexlean/target-program/1"},"sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/trim/provenance.json b/tests/production-export/stdlib/packages/rust-std/trim/provenance.json index b1fe482e2..dbaa2d452 100644 --- a/tests/production-export/stdlib/packages/rust-std/trim/provenance.json +++ b/tests/production-export/stdlib/packages/rust-std/trim/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"177bb2192e3758151d1838757adc34d91380a78d0d3c0d315694c6fac2da6618","src/lib.rs":"f57aaf2f65cc974d6053dbf690da0824652e28ae5e6761eb9bb01cdfe9492067"},"name":"trim","profile":"rust-std","program":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5bfc6ad2db2940a1b7735f1309be47dcc4b5143d58cd00cbd6745311cf1f27ee"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"177bb2192e3758151d1838757adc34d91380a78d0d3c0d315694c6fac2da6618","src/lib.rs":"f57aaf2f65cc974d6053dbf690da0824652e28ae5e6761eb9bb01cdfe9492067"},"name":"trim","profile":"rust-std","program":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["f6fd2434413f885eb97b3577e92c070677f6cd19f86ace77b5a60247639270b1"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/tooling/commands/expected/build/manifest.json b/tests/tooling/commands/expected/build/manifest.json index f6beea887..2da12061b 100644 --- a/tests/tooling/commands/expected/build/manifest.json +++ b/tests/tooling/commands/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"31edfdcdb9d7a4a87ac788ac6a91bec895470172f7765de2e298d31ba49ea7e1","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"c442ed0e043a175015e804b79e379c42714e7665a51d7ad36e25c1e0da9b4861"},{"byte_length":653,"kind":"project-config","path":"lexlean.toml","sha256":"000fa39a96ae620f80489fd4d7aa5bd620bf63e8d95e237b89a0b630f07007b0"},{"byte_length":19993,"kind":"source","path":"src/Main.lex.tex","sha256":"5800715dce08fdc9bb05acc4dcd61ae45a6f975b55dc9d6dfc877a8b4798da13"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingCommands.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":12401,"kind":"coverage","path":"coverage/ToolingCommands/Main.coverage.json","sha256":"02e19aa1dc473e65f8a87c22e614231e3d257e408ca43199b4e8eb3bd08893b0"},{"byte_length":1420,"kind":"lean","path":"modules/ToolingCommands/Main.lean","sha256":"38396294e0a117e75ce20bc8b741600264401adb391acb47638f1ae75f30db94"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":8122,"kind":"map","path":"maps/ToolingCommands/Main.map.json","sha256":"69c703430bdca98342cc279011b35371a9b7493c0a68331500d6823c20e48a28"},{"byte_length":13591,"kind":"tex","path":"modules/ToolingCommands/Main.tex","sha256":"38c0c5a259c3d8e600dad43081abe7e842365fc5ca7a21bb88123b2e49434bb9"}],"project":"tooling-commands","selection":["Main"],"semantic_id":"e142ed0b77c34e3e61315ab8c4429e6fb022dca0684f34e611095679fb81a216","source_id":"ad47e4133072b0fd3a31e9848eeb1d8d5b35a9818ea798aabdf8a4e376aa99ba","spec":"lexlean/build-manifest/1"} +{"build_id":"3f627fb7508a78363d2fb35a66c9ee3b61e6de6fa6a4347951e5853aa39a310c","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"d2dac4072fc8daf6e8803484e34984ef7fa49693cf0d2b8b31a57fcf8b5f0264"},{"byte_length":653,"kind":"project-config","path":"lexlean.toml","sha256":"000fa39a96ae620f80489fd4d7aa5bd620bf63e8d95e237b89a0b630f07007b0"},{"byte_length":19993,"kind":"source","path":"src/Main.lex.tex","sha256":"5800715dce08fdc9bb05acc4dcd61ae45a6f975b55dc9d6dfc877a8b4798da13"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingCommands.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":12401,"kind":"coverage","path":"coverage/ToolingCommands/Main.coverage.json","sha256":"02e19aa1dc473e65f8a87c22e614231e3d257e408ca43199b4e8eb3bd08893b0"},{"byte_length":1420,"kind":"lean","path":"modules/ToolingCommands/Main.lean","sha256":"38396294e0a117e75ce20bc8b741600264401adb391acb47638f1ae75f30db94"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":8122,"kind":"map","path":"maps/ToolingCommands/Main.map.json","sha256":"c0ee1410db5ebd20d67ca5a4eed962ccff1794f37386e35595f8ef3f1241dee6"},{"byte_length":13591,"kind":"tex","path":"modules/ToolingCommands/Main.tex","sha256":"38c0c5a259c3d8e600dad43081abe7e842365fc5ca7a21bb88123b2e49434bb9"}],"project":"tooling-commands","selection":["Main"],"semantic_id":"eb9bbdf568bc93c4cc0a82086d442aa1240ceec70abc45ce0969b102b0b50b74","source_id":"ba4f8363dc2f80d3b045284ba43dcfb33b07fe825a04816d984cb539af4b472a","spec":"lexlean/build-manifest/1"} diff --git a/tests/tooling/commands/expected/build/maps/ToolingCommands/Main.map.json b/tests/tooling/commands/expected/build/maps/ToolingCommands/Main.map.json index 3df40b75f..0d3e6d4d8 100644 --- a/tests/tooling/commands/expected/build/maps/ToolingCommands/Main.map.json +++ b/tests/tooling/commands/expected/build/maps/ToolingCommands/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingCommands/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingCommands/Main.tex"}],"mappings":[{"artifact":0,"gen_end":114,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":0,"gen_end":518,"gen_start":114,"node":1,"role":"declaration","source":0,"src_end":16486,"src_start":14504},{"artifact":0,"gen_end":659,"gen_start":518,"node":2,"role":"declaration","source":0,"src_end":16653,"src_start":16492},{"artifact":0,"gen_end":1000,"gen_start":659,"node":3,"role":"declaration","source":0,"src_end":18095,"src_start":16659},{"artifact":0,"gen_end":1088,"gen_start":1000,"node":4,"role":"declaration","source":0,"src_end":18432,"src_start":18101},{"artifact":0,"gen_end":1190,"gen_start":1088,"node":5,"role":"declaration","source":0,"src_end":18907,"src_start":18438},{"artifact":0,"gen_end":1349,"gen_start":1190,"node":6,"role":"declaration","source":0,"src_end":19594,"src_start":18913},{"artifact":0,"gen_end":1400,"gen_start":1349,"node":7,"role":"declaration","source":0,"src_end":19884,"src_start":19600},{"artifact":0,"gen_end":1420,"gen_start":1400,"node":8,"role":"declaration","source":0,"src_end":19937,"src_start":19890},{"artifact":0,"gen_end":1420,"gen_start":1420,"node":0,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":1,"gen_end":406,"gen_start":133,"node":10,"role":"declaration","source":0,"src_end":548,"src_start":269},{"artifact":1,"gen_end":661,"gen_start":406,"node":11,"role":"declaration","source":0,"src_end":805,"src_start":554},{"artifact":1,"gen_end":969,"gen_start":661,"node":12,"role":"declaration","source":0,"src_end":1090,"src_start":811},{"artifact":1,"gen_end":1299,"gen_start":969,"node":13,"role":"declaration","source":0,"src_end":1397,"src_start":1096},{"artifact":1,"gen_end":1547,"gen_start":1299,"node":14,"role":"declaration","source":0,"src_end":1647,"src_start":1403},{"artifact":1,"gen_end":1847,"gen_start":1547,"node":15,"role":"declaration","source":0,"src_end":1927,"src_start":1653},{"artifact":1,"gen_end":2147,"gen_start":1847,"node":16,"role":"declaration","source":0,"src_end":2207,"src_start":1933},{"artifact":1,"gen_end":2397,"gen_start":2147,"node":17,"role":"declaration","source":0,"src_end":2459,"src_start":2213},{"artifact":1,"gen_end":2808,"gen_start":2397,"node":18,"role":"declaration","source":0,"src_end":3343,"src_start":2465},{"artifact":1,"gen_end":3302,"gen_start":2808,"node":19,"role":"declaration","source":0,"src_end":4668,"src_start":3349},{"artifact":1,"gen_end":3573,"gen_start":3302,"node":20,"role":"declaration","source":0,"src_end":4916,"src_start":4674},{"artifact":1,"gen_end":4018,"gen_start":3573,"node":21,"role":"declaration","source":0,"src_end":5915,"src_start":4922},{"artifact":1,"gen_end":4418,"gen_start":4018,"node":22,"role":"declaration","source":0,"src_end":6521,"src_start":5921},{"artifact":1,"gen_end":4725,"gen_start":4418,"node":23,"role":"declaration","source":0,"src_end":6833,"src_start":6527},{"artifact":1,"gen_end":5050,"gen_start":4725,"node":24,"role":"declaration","source":0,"src_end":7215,"src_start":6839},{"artifact":1,"gen_end":5401,"gen_start":5050,"node":25,"role":"declaration","source":0,"src_end":7684,"src_start":7221},{"artifact":1,"gen_end":5867,"gen_start":5401,"node":26,"role":"declaration","source":0,"src_end":8512,"src_start":7690},{"artifact":1,"gen_end":6132,"gen_start":5867,"node":27,"role":"declaration","source":0,"src_end":8777,"src_start":8518},{"artifact":1,"gen_end":6445,"gen_start":6132,"node":28,"role":"declaration","source":0,"src_end":9070,"src_start":8783},{"artifact":1,"gen_end":6758,"gen_start":6445,"node":29,"role":"declaration","source":0,"src_end":9361,"src_start":9076},{"artifact":1,"gen_end":7011,"gen_start":6758,"node":30,"role":"declaration","source":0,"src_end":9616,"src_start":9367},{"artifact":1,"gen_end":7312,"gen_start":7011,"node":31,"role":"declaration","source":0,"src_end":9897,"src_start":9622},{"artifact":1,"gen_end":7559,"gen_start":7312,"node":32,"role":"declaration","source":0,"src_end":10146,"src_start":9903},{"artifact":1,"gen_end":7823,"gen_start":7559,"node":33,"role":"declaration","source":0,"src_end":10410,"src_start":10152},{"artifact":1,"gen_end":8136,"gen_start":7823,"node":34,"role":"declaration","source":0,"src_end":10698,"src_start":10416},{"artifact":1,"gen_end":8398,"gen_start":8136,"node":35,"role":"declaration","source":0,"src_end":10960,"src_start":10704},{"artifact":1,"gen_end":8717,"gen_start":8398,"node":36,"role":"declaration","source":0,"src_end":11452,"src_start":10966},{"artifact":1,"gen_end":11068,"gen_start":8717,"node":37,"role":"declaration","source":0,"src_end":14498,"src_start":11458},{"artifact":1,"gen_end":11666,"gen_start":11068,"node":38,"role":"declaration","source":0,"src_end":16486,"src_start":14504},{"artifact":1,"gen_end":11921,"gen_start":11666,"node":39,"role":"declaration","source":0,"src_end":16653,"src_start":16492},{"artifact":1,"gen_end":12443,"gen_start":11921,"node":40,"role":"declaration","source":0,"src_end":18095,"src_start":16659},{"artifact":1,"gen_end":12701,"gen_start":12443,"node":41,"role":"declaration","source":0,"src_end":18432,"src_start":18101},{"artifact":1,"gen_end":12966,"gen_start":12701,"node":42,"role":"declaration","source":0,"src_end":18907,"src_start":18438},{"artifact":1,"gen_end":13297,"gen_start":12966,"node":43,"role":"declaration","source":0,"src_end":19594,"src_start":18913},{"artifact":1,"gen_end":13458,"gen_start":13297,"node":44,"role":"declaration","source":0,"src_end":19884,"src_start":19600},{"artifact":1,"gen_end":13576,"gen_start":13458,"node":45,"role":"declaration","source":0,"src_end":19937,"src_start":19890},{"artifact":1,"gen_end":13591,"gen_start":13576,"node":9,"role":"declaration","source":0,"src_end":19993,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-declaration"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-latex-module"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-declaration"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"},{"id":31,"kind":"tooling-declaration"},{"id":32,"kind":"tooling-declaration"},{"id":33,"kind":"tooling-declaration"},{"id":34,"kind":"tooling-declaration"},{"id":35,"kind":"tooling-declaration"},{"id":36,"kind":"tooling-declaration"},{"id":37,"kind":"tooling-declaration"},{"id":38,"kind":"tooling-declaration"},{"id":39,"kind":"tooling-declaration"},{"id":40,"kind":"tooling-declaration"},{"id":41,"kind":"tooling-declaration"},{"id":42,"kind":"tooling-declaration"},{"id":43,"kind":"tooling-declaration"},{"id":44,"kind":"tooling-declaration"},{"id":45,"kind":"tooling-declaration"}],"semantic_id":"e142ed0b77c34e3e61315ab8c4429e6fb022dca0684f34e611095679fb81a216","source_id":"ad47e4133072b0fd3a31e9848eeb1d8d5b35a9818ea798aabdf8a4e376aa99ba","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"5800715dce08fdc9bb05acc4dcd61ae45a6f975b55dc9d6dfc877a8b4798da13"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingCommands/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingCommands/Main.tex"}],"mappings":[{"artifact":0,"gen_end":114,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":0,"gen_end":518,"gen_start":114,"node":1,"role":"declaration","source":0,"src_end":16486,"src_start":14504},{"artifact":0,"gen_end":659,"gen_start":518,"node":2,"role":"declaration","source":0,"src_end":16653,"src_start":16492},{"artifact":0,"gen_end":1000,"gen_start":659,"node":3,"role":"declaration","source":0,"src_end":18095,"src_start":16659},{"artifact":0,"gen_end":1088,"gen_start":1000,"node":4,"role":"declaration","source":0,"src_end":18432,"src_start":18101},{"artifact":0,"gen_end":1190,"gen_start":1088,"node":5,"role":"declaration","source":0,"src_end":18907,"src_start":18438},{"artifact":0,"gen_end":1349,"gen_start":1190,"node":6,"role":"declaration","source":0,"src_end":19594,"src_start":18913},{"artifact":0,"gen_end":1400,"gen_start":1349,"node":7,"role":"declaration","source":0,"src_end":19884,"src_start":19600},{"artifact":0,"gen_end":1420,"gen_start":1400,"node":8,"role":"declaration","source":0,"src_end":19937,"src_start":19890},{"artifact":0,"gen_end":1420,"gen_start":1420,"node":0,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":9,"role":"declaration","source":0,"src_end":19993,"src_start":0},{"artifact":1,"gen_end":406,"gen_start":133,"node":10,"role":"declaration","source":0,"src_end":548,"src_start":269},{"artifact":1,"gen_end":661,"gen_start":406,"node":11,"role":"declaration","source":0,"src_end":805,"src_start":554},{"artifact":1,"gen_end":969,"gen_start":661,"node":12,"role":"declaration","source":0,"src_end":1090,"src_start":811},{"artifact":1,"gen_end":1299,"gen_start":969,"node":13,"role":"declaration","source":0,"src_end":1397,"src_start":1096},{"artifact":1,"gen_end":1547,"gen_start":1299,"node":14,"role":"declaration","source":0,"src_end":1647,"src_start":1403},{"artifact":1,"gen_end":1847,"gen_start":1547,"node":15,"role":"declaration","source":0,"src_end":1927,"src_start":1653},{"artifact":1,"gen_end":2147,"gen_start":1847,"node":16,"role":"declaration","source":0,"src_end":2207,"src_start":1933},{"artifact":1,"gen_end":2397,"gen_start":2147,"node":17,"role":"declaration","source":0,"src_end":2459,"src_start":2213},{"artifact":1,"gen_end":2808,"gen_start":2397,"node":18,"role":"declaration","source":0,"src_end":3343,"src_start":2465},{"artifact":1,"gen_end":3302,"gen_start":2808,"node":19,"role":"declaration","source":0,"src_end":4668,"src_start":3349},{"artifact":1,"gen_end":3573,"gen_start":3302,"node":20,"role":"declaration","source":0,"src_end":4916,"src_start":4674},{"artifact":1,"gen_end":4018,"gen_start":3573,"node":21,"role":"declaration","source":0,"src_end":5915,"src_start":4922},{"artifact":1,"gen_end":4418,"gen_start":4018,"node":22,"role":"declaration","source":0,"src_end":6521,"src_start":5921},{"artifact":1,"gen_end":4725,"gen_start":4418,"node":23,"role":"declaration","source":0,"src_end":6833,"src_start":6527},{"artifact":1,"gen_end":5050,"gen_start":4725,"node":24,"role":"declaration","source":0,"src_end":7215,"src_start":6839},{"artifact":1,"gen_end":5401,"gen_start":5050,"node":25,"role":"declaration","source":0,"src_end":7684,"src_start":7221},{"artifact":1,"gen_end":5867,"gen_start":5401,"node":26,"role":"declaration","source":0,"src_end":8512,"src_start":7690},{"artifact":1,"gen_end":6132,"gen_start":5867,"node":27,"role":"declaration","source":0,"src_end":8777,"src_start":8518},{"artifact":1,"gen_end":6445,"gen_start":6132,"node":28,"role":"declaration","source":0,"src_end":9070,"src_start":8783},{"artifact":1,"gen_end":6758,"gen_start":6445,"node":29,"role":"declaration","source":0,"src_end":9361,"src_start":9076},{"artifact":1,"gen_end":7011,"gen_start":6758,"node":30,"role":"declaration","source":0,"src_end":9616,"src_start":9367},{"artifact":1,"gen_end":7312,"gen_start":7011,"node":31,"role":"declaration","source":0,"src_end":9897,"src_start":9622},{"artifact":1,"gen_end":7559,"gen_start":7312,"node":32,"role":"declaration","source":0,"src_end":10146,"src_start":9903},{"artifact":1,"gen_end":7823,"gen_start":7559,"node":33,"role":"declaration","source":0,"src_end":10410,"src_start":10152},{"artifact":1,"gen_end":8136,"gen_start":7823,"node":34,"role":"declaration","source":0,"src_end":10698,"src_start":10416},{"artifact":1,"gen_end":8398,"gen_start":8136,"node":35,"role":"declaration","source":0,"src_end":10960,"src_start":10704},{"artifact":1,"gen_end":8717,"gen_start":8398,"node":36,"role":"declaration","source":0,"src_end":11452,"src_start":10966},{"artifact":1,"gen_end":11068,"gen_start":8717,"node":37,"role":"declaration","source":0,"src_end":14498,"src_start":11458},{"artifact":1,"gen_end":11666,"gen_start":11068,"node":38,"role":"declaration","source":0,"src_end":16486,"src_start":14504},{"artifact":1,"gen_end":11921,"gen_start":11666,"node":39,"role":"declaration","source":0,"src_end":16653,"src_start":16492},{"artifact":1,"gen_end":12443,"gen_start":11921,"node":40,"role":"declaration","source":0,"src_end":18095,"src_start":16659},{"artifact":1,"gen_end":12701,"gen_start":12443,"node":41,"role":"declaration","source":0,"src_end":18432,"src_start":18101},{"artifact":1,"gen_end":12966,"gen_start":12701,"node":42,"role":"declaration","source":0,"src_end":18907,"src_start":18438},{"artifact":1,"gen_end":13297,"gen_start":12966,"node":43,"role":"declaration","source":0,"src_end":19594,"src_start":18913},{"artifact":1,"gen_end":13458,"gen_start":13297,"node":44,"role":"declaration","source":0,"src_end":19884,"src_start":19600},{"artifact":1,"gen_end":13576,"gen_start":13458,"node":45,"role":"declaration","source":0,"src_end":19937,"src_start":19890},{"artifact":1,"gen_end":13591,"gen_start":13576,"node":9,"role":"declaration","source":0,"src_end":19993,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-declaration"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-latex-module"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-declaration"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"},{"id":31,"kind":"tooling-declaration"},{"id":32,"kind":"tooling-declaration"},{"id":33,"kind":"tooling-declaration"},{"id":34,"kind":"tooling-declaration"},{"id":35,"kind":"tooling-declaration"},{"id":36,"kind":"tooling-declaration"},{"id":37,"kind":"tooling-declaration"},{"id":38,"kind":"tooling-declaration"},{"id":39,"kind":"tooling-declaration"},{"id":40,"kind":"tooling-declaration"},{"id":41,"kind":"tooling-declaration"},{"id":42,"kind":"tooling-declaration"},{"id":43,"kind":"tooling-declaration"},{"id":44,"kind":"tooling-declaration"},{"id":45,"kind":"tooling-declaration"}],"semantic_id":"eb9bbdf568bc93c4cc0a82086d442aa1240ceec70abc45ce0969b102b0b50b74","source_id":"ba4f8363dc2f80d3b045284ba43dcfb33b07fe825a04816d984cb539af4b472a","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"5800715dce08fdc9bb05acc4dcd61ae45a6f975b55dc9d6dfc877a8b4798da13"}],"spec":"lexlean/source-map/1"} diff --git a/tests/tooling/core/expected/build/manifest.json b/tests/tooling/core/expected/build/manifest.json index 25d8e61d8..d7056851d 100644 --- a/tests/tooling/core/expected/build/manifest.json +++ b/tests/tooling/core/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"e177c0cb551bfd7bd6a79141079d6f7e5e9da5297d94c055ea89921a84b42336","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"8226a018139a31e4891cd0429e5b6a748f0c11b572285d15976aa67f3ccbb226"},{"byte_length":645,"kind":"project-config","path":"lexlean.toml","sha256":"238e7aca6dbdb072aca261449c9bd60440763fbf9d421fdde4d29f286ff968b4"},{"byte_length":14154,"kind":"source","path":"src/Main.lex.tex","sha256":"d611da375d88aa3efe36b73131554920015825a0d05c0cdfc1b9e50d357e3a6e"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingCore.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":12100,"kind":"coverage","path":"coverage/ToolingCore/Main.coverage.json","sha256":"fa68401f794e7224cf2e10d57e7cd0eb4bdc82dffa1ce179d0a0c48b2686204b"},{"byte_length":1612,"kind":"lean","path":"modules/ToolingCore/Main.lean","sha256":"3382b759545d15d0cb3ac2cb3ea08833f13656dd0540dcc962d8a2710a30f935"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":7755,"kind":"map","path":"maps/ToolingCore/Main.map.json","sha256":"fb5ce45c34ec1592e222361a6e6cf55bae76d8aa945987ec2a469148a1f820ed"},{"byte_length":8320,"kind":"tex","path":"modules/ToolingCore/Main.tex","sha256":"386777537e87ff79421132913e55382244ba72e469fa00db76765a830658d42f"}],"project":"tooling-core","selection":["Main"],"semantic_id":"83f4bed424bc1989b14ddf52d5a1167c1d2838d34fbabc0f3f41610723cec7ab","source_id":"081d5123ba5e046a560480082f56ce1859cfa626307eef53630b1f0f4c92142d","spec":"lexlean/build-manifest/1"} +{"build_id":"d02fde77b13dd736acb15297b269a2c47a841e0fe17f4cc68b9a28e542b23e37","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"632720d3d94f8f4abcc671155f1f12d6937356d7f3db815e3ab7d8de4ce769f6"},{"byte_length":645,"kind":"project-config","path":"lexlean.toml","sha256":"238e7aca6dbdb072aca261449c9bd60440763fbf9d421fdde4d29f286ff968b4"},{"byte_length":14154,"kind":"source","path":"src/Main.lex.tex","sha256":"d611da375d88aa3efe36b73131554920015825a0d05c0cdfc1b9e50d357e3a6e"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingCore.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":12100,"kind":"coverage","path":"coverage/ToolingCore/Main.coverage.json","sha256":"fa68401f794e7224cf2e10d57e7cd0eb4bdc82dffa1ce179d0a0c48b2686204b"},{"byte_length":1612,"kind":"lean","path":"modules/ToolingCore/Main.lean","sha256":"3382b759545d15d0cb3ac2cb3ea08833f13656dd0540dcc962d8a2710a30f935"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":7755,"kind":"map","path":"maps/ToolingCore/Main.map.json","sha256":"2a18114e44e174957e1ab069275b8f275f764dd95c6971b5cf5642e8c1564075"},{"byte_length":8320,"kind":"tex","path":"modules/ToolingCore/Main.tex","sha256":"386777537e87ff79421132913e55382244ba72e469fa00db76765a830658d42f"}],"project":"tooling-core","selection":["Main"],"semantic_id":"37c360ca687bfe26cef1f43d257482c96e322ebc80a66882992634a315cb3fb0","source_id":"b09e666b29108c192788640ce5868612d7fb07a5dabbdec58003a8aeb11261df","spec":"lexlean/build-manifest/1"} diff --git a/tests/tooling/core/expected/build/maps/ToolingCore/Main.map.json b/tests/tooling/core/expected/build/maps/ToolingCore/Main.map.json index 673a2d71f..81899aad4 100644 --- a/tests/tooling/core/expected/build/maps/ToolingCore/Main.map.json +++ b/tests/tooling/core/expected/build/maps/ToolingCore/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingCore/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingCore/Main.tex"}],"mappings":[{"artifact":0,"gen_end":118,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":0,"gen_end":249,"gen_start":118,"node":1,"role":"declaration","source":0,"src_end":6580,"src_start":5792},{"artifact":0,"gen_end":404,"gen_start":249,"node":2,"role":"declaration","source":0,"src_end":7496,"src_start":6586},{"artifact":0,"gen_end":548,"gen_start":404,"node":3,"role":"declaration","source":0,"src_end":8300,"src_start":7502},{"artifact":0,"gen_end":684,"gen_start":548,"node":4,"role":"declaration","source":0,"src_end":9080,"src_start":8306},{"artifact":0,"gen_end":755,"gen_start":684,"node":5,"role":"declaration","source":0,"src_end":9512,"src_start":9086},{"artifact":0,"gen_end":850,"gen_start":755,"node":6,"role":"declaration","source":0,"src_end":9997,"src_start":9518},{"artifact":0,"gen_end":924,"gen_start":850,"node":7,"role":"declaration","source":0,"src_end":10360,"src_start":10003},{"artifact":0,"gen_end":991,"gen_start":924,"node":8,"role":"declaration","source":0,"src_end":10703,"src_start":10366},{"artifact":0,"gen_end":1070,"gen_start":991,"node":9,"role":"declaration","source":0,"src_end":11276,"src_start":10709},{"artifact":0,"gen_end":1172,"gen_start":1070,"node":10,"role":"declaration","source":0,"src_end":11793,"src_start":11282},{"artifact":0,"gen_end":1282,"gen_start":1172,"node":11,"role":"declaration","source":0,"src_end":12390,"src_start":11799},{"artifact":0,"gen_end":1350,"gen_start":1282,"node":12,"role":"declaration","source":0,"src_end":12711,"src_start":12396},{"artifact":0,"gen_end":1482,"gen_start":1350,"node":13,"role":"declaration","source":0,"src_end":13404,"src_start":12717},{"artifact":0,"gen_end":1612,"gen_start":1482,"node":14,"role":"declaration","source":0,"src_end":14098,"src_start":13410},{"artifact":0,"gen_end":1612,"gen_start":1612,"node":0,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":15,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":1,"gen_end":406,"gen_start":133,"node":16,"role":"declaration","source":0,"src_end":548,"src_start":269},{"artifact":1,"gen_end":686,"gen_start":406,"node":17,"role":"declaration","source":0,"src_end":899,"src_start":554},{"artifact":1,"gen_end":1050,"gen_start":686,"node":18,"role":"declaration","source":0,"src_end":1440,"src_start":905},{"artifact":1,"gen_end":1300,"gen_start":1050,"node":19,"role":"declaration","source":0,"src_end":1692,"src_start":1446},{"artifact":1,"gen_end":1548,"gen_start":1300,"node":20,"role":"declaration","source":0,"src_end":1942,"src_start":1698},{"artifact":1,"gen_end":1889,"gen_start":1548,"node":21,"role":"declaration","source":0,"src_end":2329,"src_start":1948},{"artifact":1,"gen_end":2218,"gen_start":1889,"node":22,"role":"declaration","source":0,"src_end":2829,"src_start":2335},{"artifact":1,"gen_end":2518,"gen_start":2218,"node":23,"role":"declaration","source":0,"src_end":3106,"src_start":2835},{"artifact":1,"gen_end":2816,"gen_start":2518,"node":24,"role":"declaration","source":0,"src_end":3461,"src_start":3112},{"artifact":1,"gen_end":3115,"gen_start":2816,"node":25,"role":"declaration","source":0,"src_end":3817,"src_start":3467},{"artifact":1,"gen_end":3399,"gen_start":3115,"node":26,"role":"declaration","source":0,"src_end":4106,"src_start":3823},{"artifact":1,"gen_end":3823,"gen_start":3399,"node":27,"role":"declaration","source":0,"src_end":4909,"src_start":4112},{"artifact":1,"gen_end":4145,"gen_start":3823,"node":28,"role":"declaration","source":0,"src_end":5288,"src_start":4915},{"artifact":1,"gen_end":4536,"gen_start":4145,"node":29,"role":"declaration","source":0,"src_end":5786,"src_start":5294},{"artifact":1,"gen_end":4822,"gen_start":4536,"node":30,"role":"declaration","source":0,"src_end":6580,"src_start":5792},{"artifact":1,"gen_end":5159,"gen_start":4822,"node":31,"role":"declaration","source":0,"src_end":7496,"src_start":6586},{"artifact":1,"gen_end":5461,"gen_start":5159,"node":32,"role":"declaration","source":0,"src_end":8300,"src_start":7502},{"artifact":1,"gen_end":5765,"gen_start":5461,"node":33,"role":"declaration","source":0,"src_end":9080,"src_start":8306},{"artifact":1,"gen_end":5991,"gen_start":5765,"node":34,"role":"declaration","source":0,"src_end":9512,"src_start":9086},{"artifact":1,"gen_end":6252,"gen_start":5991,"node":35,"role":"declaration","source":0,"src_end":9997,"src_start":9518},{"artifact":1,"gen_end":6482,"gen_start":6252,"node":36,"role":"declaration","source":0,"src_end":10360,"src_start":10003},{"artifact":1,"gen_end":6703,"gen_start":6482,"node":37,"role":"declaration","source":0,"src_end":10703,"src_start":10366},{"artifact":1,"gen_end":6942,"gen_start":6703,"node":38,"role":"declaration","source":0,"src_end":11276,"src_start":10709},{"artifact":1,"gen_end":7200,"gen_start":6942,"node":39,"role":"declaration","source":0,"src_end":11793,"src_start":11282},{"artifact":1,"gen_end":7468,"gen_start":7200,"node":40,"role":"declaration","source":0,"src_end":12390,"src_start":11799},{"artifact":1,"gen_end":7697,"gen_start":7468,"node":41,"role":"declaration","source":0,"src_end":12711,"src_start":12396},{"artifact":1,"gen_end":8001,"gen_start":7697,"node":42,"role":"declaration","source":0,"src_end":13404,"src_start":12717},{"artifact":1,"gen_end":8305,"gen_start":8001,"node":43,"role":"declaration","source":0,"src_end":14098,"src_start":13410},{"artifact":1,"gen_end":8320,"gen_start":8305,"node":15,"role":"declaration","source":0,"src_end":14154,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-declaration"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-declaration"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-latex-module"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"},{"id":31,"kind":"tooling-declaration"},{"id":32,"kind":"tooling-declaration"},{"id":33,"kind":"tooling-declaration"},{"id":34,"kind":"tooling-declaration"},{"id":35,"kind":"tooling-declaration"},{"id":36,"kind":"tooling-declaration"},{"id":37,"kind":"tooling-declaration"},{"id":38,"kind":"tooling-declaration"},{"id":39,"kind":"tooling-declaration"},{"id":40,"kind":"tooling-declaration"},{"id":41,"kind":"tooling-declaration"},{"id":42,"kind":"tooling-declaration"},{"id":43,"kind":"tooling-declaration"}],"semantic_id":"83f4bed424bc1989b14ddf52d5a1167c1d2838d34fbabc0f3f41610723cec7ab","source_id":"081d5123ba5e046a560480082f56ce1859cfa626307eef53630b1f0f4c92142d","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"d611da375d88aa3efe36b73131554920015825a0d05c0cdfc1b9e50d357e3a6e"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingCore/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingCore/Main.tex"}],"mappings":[{"artifact":0,"gen_end":118,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":0,"gen_end":249,"gen_start":118,"node":1,"role":"declaration","source":0,"src_end":6580,"src_start":5792},{"artifact":0,"gen_end":404,"gen_start":249,"node":2,"role":"declaration","source":0,"src_end":7496,"src_start":6586},{"artifact":0,"gen_end":548,"gen_start":404,"node":3,"role":"declaration","source":0,"src_end":8300,"src_start":7502},{"artifact":0,"gen_end":684,"gen_start":548,"node":4,"role":"declaration","source":0,"src_end":9080,"src_start":8306},{"artifact":0,"gen_end":755,"gen_start":684,"node":5,"role":"declaration","source":0,"src_end":9512,"src_start":9086},{"artifact":0,"gen_end":850,"gen_start":755,"node":6,"role":"declaration","source":0,"src_end":9997,"src_start":9518},{"artifact":0,"gen_end":924,"gen_start":850,"node":7,"role":"declaration","source":0,"src_end":10360,"src_start":10003},{"artifact":0,"gen_end":991,"gen_start":924,"node":8,"role":"declaration","source":0,"src_end":10703,"src_start":10366},{"artifact":0,"gen_end":1070,"gen_start":991,"node":9,"role":"declaration","source":0,"src_end":11276,"src_start":10709},{"artifact":0,"gen_end":1172,"gen_start":1070,"node":10,"role":"declaration","source":0,"src_end":11793,"src_start":11282},{"artifact":0,"gen_end":1282,"gen_start":1172,"node":11,"role":"declaration","source":0,"src_end":12390,"src_start":11799},{"artifact":0,"gen_end":1350,"gen_start":1282,"node":12,"role":"declaration","source":0,"src_end":12711,"src_start":12396},{"artifact":0,"gen_end":1482,"gen_start":1350,"node":13,"role":"declaration","source":0,"src_end":13404,"src_start":12717},{"artifact":0,"gen_end":1612,"gen_start":1482,"node":14,"role":"declaration","source":0,"src_end":14098,"src_start":13410},{"artifact":0,"gen_end":1612,"gen_start":1612,"node":0,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":15,"role":"declaration","source":0,"src_end":14154,"src_start":0},{"artifact":1,"gen_end":406,"gen_start":133,"node":16,"role":"declaration","source":0,"src_end":548,"src_start":269},{"artifact":1,"gen_end":686,"gen_start":406,"node":17,"role":"declaration","source":0,"src_end":899,"src_start":554},{"artifact":1,"gen_end":1050,"gen_start":686,"node":18,"role":"declaration","source":0,"src_end":1440,"src_start":905},{"artifact":1,"gen_end":1300,"gen_start":1050,"node":19,"role":"declaration","source":0,"src_end":1692,"src_start":1446},{"artifact":1,"gen_end":1548,"gen_start":1300,"node":20,"role":"declaration","source":0,"src_end":1942,"src_start":1698},{"artifact":1,"gen_end":1889,"gen_start":1548,"node":21,"role":"declaration","source":0,"src_end":2329,"src_start":1948},{"artifact":1,"gen_end":2218,"gen_start":1889,"node":22,"role":"declaration","source":0,"src_end":2829,"src_start":2335},{"artifact":1,"gen_end":2518,"gen_start":2218,"node":23,"role":"declaration","source":0,"src_end":3106,"src_start":2835},{"artifact":1,"gen_end":2816,"gen_start":2518,"node":24,"role":"declaration","source":0,"src_end":3461,"src_start":3112},{"artifact":1,"gen_end":3115,"gen_start":2816,"node":25,"role":"declaration","source":0,"src_end":3817,"src_start":3467},{"artifact":1,"gen_end":3399,"gen_start":3115,"node":26,"role":"declaration","source":0,"src_end":4106,"src_start":3823},{"artifact":1,"gen_end":3823,"gen_start":3399,"node":27,"role":"declaration","source":0,"src_end":4909,"src_start":4112},{"artifact":1,"gen_end":4145,"gen_start":3823,"node":28,"role":"declaration","source":0,"src_end":5288,"src_start":4915},{"artifact":1,"gen_end":4536,"gen_start":4145,"node":29,"role":"declaration","source":0,"src_end":5786,"src_start":5294},{"artifact":1,"gen_end":4822,"gen_start":4536,"node":30,"role":"declaration","source":0,"src_end":6580,"src_start":5792},{"artifact":1,"gen_end":5159,"gen_start":4822,"node":31,"role":"declaration","source":0,"src_end":7496,"src_start":6586},{"artifact":1,"gen_end":5461,"gen_start":5159,"node":32,"role":"declaration","source":0,"src_end":8300,"src_start":7502},{"artifact":1,"gen_end":5765,"gen_start":5461,"node":33,"role":"declaration","source":0,"src_end":9080,"src_start":8306},{"artifact":1,"gen_end":5991,"gen_start":5765,"node":34,"role":"declaration","source":0,"src_end":9512,"src_start":9086},{"artifact":1,"gen_end":6252,"gen_start":5991,"node":35,"role":"declaration","source":0,"src_end":9997,"src_start":9518},{"artifact":1,"gen_end":6482,"gen_start":6252,"node":36,"role":"declaration","source":0,"src_end":10360,"src_start":10003},{"artifact":1,"gen_end":6703,"gen_start":6482,"node":37,"role":"declaration","source":0,"src_end":10703,"src_start":10366},{"artifact":1,"gen_end":6942,"gen_start":6703,"node":38,"role":"declaration","source":0,"src_end":11276,"src_start":10709},{"artifact":1,"gen_end":7200,"gen_start":6942,"node":39,"role":"declaration","source":0,"src_end":11793,"src_start":11282},{"artifact":1,"gen_end":7468,"gen_start":7200,"node":40,"role":"declaration","source":0,"src_end":12390,"src_start":11799},{"artifact":1,"gen_end":7697,"gen_start":7468,"node":41,"role":"declaration","source":0,"src_end":12711,"src_start":12396},{"artifact":1,"gen_end":8001,"gen_start":7697,"node":42,"role":"declaration","source":0,"src_end":13404,"src_start":12717},{"artifact":1,"gen_end":8305,"gen_start":8001,"node":43,"role":"declaration","source":0,"src_end":14098,"src_start":13410},{"artifact":1,"gen_end":8320,"gen_start":8305,"node":15,"role":"declaration","source":0,"src_end":14154,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-declaration"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-declaration"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-latex-module"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"},{"id":31,"kind":"tooling-declaration"},{"id":32,"kind":"tooling-declaration"},{"id":33,"kind":"tooling-declaration"},{"id":34,"kind":"tooling-declaration"},{"id":35,"kind":"tooling-declaration"},{"id":36,"kind":"tooling-declaration"},{"id":37,"kind":"tooling-declaration"},{"id":38,"kind":"tooling-declaration"},{"id":39,"kind":"tooling-declaration"},{"id":40,"kind":"tooling-declaration"},{"id":41,"kind":"tooling-declaration"},{"id":42,"kind":"tooling-declaration"},{"id":43,"kind":"tooling-declaration"}],"semantic_id":"37c360ca687bfe26cef1f43d257482c96e322ebc80a66882992634a315cb3fb0","source_id":"b09e666b29108c192788640ce5868612d7fb07a5dabbdec58003a8aeb11261df","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"d611da375d88aa3efe36b73131554920015825a0d05c0cdfc1b9e50d357e3a6e"}],"spec":"lexlean/source-map/1"} diff --git a/tests/tooling/traversal/expected/build/manifest.json b/tests/tooling/traversal/expected/build/manifest.json index 017f3790f..e8d09d737 100644 --- a/tests/tooling/traversal/expected/build/manifest.json +++ b/tests/tooling/traversal/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"75b958de8ef1cbd2900c3c7d0e1e3bb7636f3de61ed2844192812d18f962ead3","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"04b2a3f9ec2cef98878c609f52231bbea2687eb7009a6e496362ca1ebb3dd9cc"},{"byte_length":655,"kind":"project-config","path":"lexlean.toml","sha256":"6ca06ebfa2d29813b86b2c3f03d84db119724d4af5bc00d8fed779d27cbd6c21"},{"byte_length":24781,"kind":"source","path":"src/Main.lex.tex","sha256":"67110e50b1b9a593a0b92051a0922a3484384db0a1f6845f04b901adf80e81ac"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingTraversal.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":10404,"kind":"coverage","path":"coverage/ToolingTraversal/Main.coverage.json","sha256":"2211e359fb6745e9b1470a433f2ded42619616d7f056fcd644bdd566b7cceb2a"},{"byte_length":1451,"kind":"lean","path":"modules/ToolingTraversal/Main.lean","sha256":"50e1bc0cc45ca86a532ac775ef794454cd74d7bc19b41e749d930c1b4749e657"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":5728,"kind":"map","path":"maps/ToolingTraversal/Main.map.json","sha256":"66e035a25e71f3421b84f6c8409a9abb7e3d298a871e36baeab9eb6099d28ce2"},{"byte_length":11798,"kind":"tex","path":"modules/ToolingTraversal/Main.tex","sha256":"e7cae90c6a1cd1d9fa94610f688a123728c3f12daaa7020f7dcf900bced7bc13"}],"project":"tooling-traversal","selection":["Main"],"semantic_id":"0c3eb2fb59a6c938b70620859d8e1d5e3e5850aa2d36d86d1549da6408659cb5","source_id":"0a02e2f8ca32d267f3aa7fe0716ccda40658086e99ed359bc8ccc994685a5959","spec":"lexlean/build-manifest/1"} +{"build_id":"b803ec6666f177f3cc5d21593f4bdfb6e19f5b99d80e9357d97d20341239f60f","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"7ff213824bf25ba1d596408b1f1a53c0f4445bbd3e570df6d3a8838c54006820"},{"byte_length":655,"kind":"project-config","path":"lexlean.toml","sha256":"6ca06ebfa2d29813b86b2c3f03d84db119724d4af5bc00d8fed779d27cbd6c21"},{"byte_length":24781,"kind":"source","path":"src/Main.lex.tex","sha256":"67110e50b1b9a593a0b92051a0922a3484384db0a1f6845f04b901adf80e81ac"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"ToolingTraversal.Main","module":"Main","source_path":"src/Main.lex.tex"}],"outputs":[{"byte_length":10404,"kind":"coverage","path":"coverage/ToolingTraversal/Main.coverage.json","sha256":"2211e359fb6745e9b1470a433f2ded42619616d7f056fcd644bdd566b7cceb2a"},{"byte_length":1451,"kind":"lean","path":"modules/ToolingTraversal/Main.lean","sha256":"50e1bc0cc45ca86a532ac775ef794454cd74d7bc19b41e749d930c1b4749e657"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Main.closure.json","sha256":"727110f90daff26a2e5eb8069fcefecd5790c1264f5d6d4b2ef57db1c2bfb867"},{"byte_length":5728,"kind":"map","path":"maps/ToolingTraversal/Main.map.json","sha256":"fc942564b1723c51b83079649ce1443b5121231392c347140e85f68c3c13e7bf"},{"byte_length":11798,"kind":"tex","path":"modules/ToolingTraversal/Main.tex","sha256":"e7cae90c6a1cd1d9fa94610f688a123728c3f12daaa7020f7dcf900bced7bc13"}],"project":"tooling-traversal","selection":["Main"],"semantic_id":"2c8e8ea9e16647930ec972518ea8b7ca746f951750606bd3eb6c379ecab249cd","source_id":"8245cb4ade3e3746c75f908b8508a34c02ae089662b089b97c444a8c7d62ee79","spec":"lexlean/build-manifest/1"} diff --git a/tests/tooling/traversal/expected/build/maps/ToolingTraversal/Main.map.json b/tests/tooling/traversal/expected/build/maps/ToolingTraversal/Main.map.json index 941e30d43..b5e8326b3 100644 --- a/tests/tooling/traversal/expected/build/maps/ToolingTraversal/Main.map.json +++ b/tests/tooling/traversal/expected/build/maps/ToolingTraversal/Main.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingTraversal/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingTraversal/Main.tex"}],"mappings":[{"artifact":0,"gen_end":114,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":0,"gen_end":560,"gen_start":114,"node":1,"role":"declaration","source":0,"src_end":20790,"src_start":18370},{"artifact":0,"gen_end":763,"gen_start":560,"node":2,"role":"declaration","source":0,"src_end":21559,"src_start":20796},{"artifact":0,"gen_end":1226,"gen_start":763,"node":3,"role":"declaration","source":0,"src_end":23775,"src_start":21565},{"artifact":0,"gen_end":1451,"gen_start":1226,"node":4,"role":"declaration","source":0,"src_end":24725,"src_start":23781},{"artifact":0,"gen_end":1451,"gen_start":1451,"node":0,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":1,"gen_end":440,"gen_start":133,"node":6,"role":"declaration","source":0,"src_end":578,"src_start":269},{"artifact":1,"gen_end":2723,"gen_start":440,"node":7,"role":"declaration","source":0,"src_end":7765,"src_start":584},{"artifact":1,"gen_end":3205,"gen_start":2723,"node":8,"role":"declaration","source":0,"src_end":8935,"src_start":7771},{"artifact":1,"gen_end":3934,"gen_start":3205,"node":9,"role":"declaration","source":0,"src_end":10780,"src_start":8941},{"artifact":1,"gen_end":4374,"gen_start":3934,"node":10,"role":"declaration","source":0,"src_end":11737,"src_start":10786},{"artifact":1,"gen_end":4680,"gen_start":4374,"node":11,"role":"declaration","source":0,"src_end":12218,"src_start":11743},{"artifact":1,"gen_end":4953,"gen_start":4680,"node":12,"role":"declaration","source":0,"src_end":12503,"src_start":12224},{"artifact":1,"gen_end":5297,"gen_start":4953,"node":13,"role":"declaration","source":0,"src_end":12837,"src_start":12509},{"artifact":1,"gen_end":5645,"gen_start":5297,"node":14,"role":"declaration","source":0,"src_end":13175,"src_start":12843},{"artifact":1,"gen_end":5895,"gen_start":5645,"node":15,"role":"declaration","source":0,"src_end":13427,"src_start":13181},{"artifact":1,"gen_end":6147,"gen_start":5895,"node":16,"role":"declaration","source":0,"src_end":13681,"src_start":13433},{"artifact":1,"gen_end":6427,"gen_start":6147,"node":17,"role":"declaration","source":0,"src_end":14032,"src_start":13687},{"artifact":1,"gen_end":6768,"gen_start":6427,"node":18,"role":"declaration","source":0,"src_end":14419,"src_start":14038},{"artifact":1,"gen_end":7114,"gen_start":6768,"node":19,"role":"declaration","source":0,"src_end":14755,"src_start":14425},{"artifact":1,"gen_end":7367,"gen_start":7114,"node":20,"role":"declaration","source":0,"src_end":15010,"src_start":14761},{"artifact":1,"gen_end":7650,"gen_start":7367,"node":21,"role":"declaration","source":0,"src_end":15295,"src_start":15016},{"artifact":1,"gen_end":8014,"gen_start":7650,"node":22,"role":"declaration","source":0,"src_end":15836,"src_start":15301},{"artifact":1,"gen_end":8312,"gen_start":8014,"node":23,"role":"declaration","source":0,"src_end":16191,"src_start":15842},{"artifact":1,"gen_end":8660,"gen_start":8312,"node":24,"role":"declaration","source":0,"src_end":16730,"src_start":16197},{"artifact":1,"gen_end":9113,"gen_start":8660,"node":25,"role":"declaration","source":0,"src_end":17658,"src_start":16736},{"artifact":1,"gen_end":9680,"gen_start":9113,"node":26,"role":"declaration","source":0,"src_end":18364,"src_start":17664},{"artifact":1,"gen_end":10335,"gen_start":9680,"node":27,"role":"declaration","source":0,"src_end":20790,"src_start":18370},{"artifact":1,"gen_end":10721,"gen_start":10335,"node":28,"role":"declaration","source":0,"src_end":21559,"src_start":20796},{"artifact":1,"gen_end":11383,"gen_start":10721,"node":29,"role":"declaration","source":0,"src_end":23775,"src_start":21565},{"artifact":1,"gen_end":11783,"gen_start":11383,"node":30,"role":"declaration","source":0,"src_end":24725,"src_start":23781},{"artifact":1,"gen_end":11798,"gen_start":11783,"node":5,"role":"declaration","source":0,"src_end":24781,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-latex-module"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-declaration"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-declaration"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"}],"semantic_id":"0c3eb2fb59a6c938b70620859d8e1d5e3e5850aa2d36d86d1549da6408659cb5","source_id":"0a02e2f8ca32d267f3aa7fe0716ccda40658086e99ed359bc8ccc994685a5959","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"67110e50b1b9a593a0b92051a0922a3484384db0a1f6845f04b901adf80e81ac"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/ToolingTraversal/Main.lean"},{"id":1,"kind":"tex","path":"modules/ToolingTraversal/Main.tex"}],"mappings":[{"artifact":0,"gen_end":114,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":0,"gen_end":560,"gen_start":114,"node":1,"role":"declaration","source":0,"src_end":20790,"src_start":18370},{"artifact":0,"gen_end":763,"gen_start":560,"node":2,"role":"declaration","source":0,"src_end":21559,"src_start":20796},{"artifact":0,"gen_end":1226,"gen_start":763,"node":3,"role":"declaration","source":0,"src_end":23775,"src_start":21565},{"artifact":0,"gen_end":1451,"gen_start":1226,"node":4,"role":"declaration","source":0,"src_end":24725,"src_start":23781},{"artifact":0,"gen_end":1451,"gen_start":1451,"node":0,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":1,"gen_end":133,"gen_start":0,"node":5,"role":"declaration","source":0,"src_end":24781,"src_start":0},{"artifact":1,"gen_end":440,"gen_start":133,"node":6,"role":"declaration","source":0,"src_end":578,"src_start":269},{"artifact":1,"gen_end":2723,"gen_start":440,"node":7,"role":"declaration","source":0,"src_end":7765,"src_start":584},{"artifact":1,"gen_end":3205,"gen_start":2723,"node":8,"role":"declaration","source":0,"src_end":8935,"src_start":7771},{"artifact":1,"gen_end":3934,"gen_start":3205,"node":9,"role":"declaration","source":0,"src_end":10780,"src_start":8941},{"artifact":1,"gen_end":4374,"gen_start":3934,"node":10,"role":"declaration","source":0,"src_end":11737,"src_start":10786},{"artifact":1,"gen_end":4680,"gen_start":4374,"node":11,"role":"declaration","source":0,"src_end":12218,"src_start":11743},{"artifact":1,"gen_end":4953,"gen_start":4680,"node":12,"role":"declaration","source":0,"src_end":12503,"src_start":12224},{"artifact":1,"gen_end":5297,"gen_start":4953,"node":13,"role":"declaration","source":0,"src_end":12837,"src_start":12509},{"artifact":1,"gen_end":5645,"gen_start":5297,"node":14,"role":"declaration","source":0,"src_end":13175,"src_start":12843},{"artifact":1,"gen_end":5895,"gen_start":5645,"node":15,"role":"declaration","source":0,"src_end":13427,"src_start":13181},{"artifact":1,"gen_end":6147,"gen_start":5895,"node":16,"role":"declaration","source":0,"src_end":13681,"src_start":13433},{"artifact":1,"gen_end":6427,"gen_start":6147,"node":17,"role":"declaration","source":0,"src_end":14032,"src_start":13687},{"artifact":1,"gen_end":6768,"gen_start":6427,"node":18,"role":"declaration","source":0,"src_end":14419,"src_start":14038},{"artifact":1,"gen_end":7114,"gen_start":6768,"node":19,"role":"declaration","source":0,"src_end":14755,"src_start":14425},{"artifact":1,"gen_end":7367,"gen_start":7114,"node":20,"role":"declaration","source":0,"src_end":15010,"src_start":14761},{"artifact":1,"gen_end":7650,"gen_start":7367,"node":21,"role":"declaration","source":0,"src_end":15295,"src_start":15016},{"artifact":1,"gen_end":8014,"gen_start":7650,"node":22,"role":"declaration","source":0,"src_end":15836,"src_start":15301},{"artifact":1,"gen_end":8312,"gen_start":8014,"node":23,"role":"declaration","source":0,"src_end":16191,"src_start":15842},{"artifact":1,"gen_end":8660,"gen_start":8312,"node":24,"role":"declaration","source":0,"src_end":16730,"src_start":16197},{"artifact":1,"gen_end":9113,"gen_start":8660,"node":25,"role":"declaration","source":0,"src_end":17658,"src_start":16736},{"artifact":1,"gen_end":9680,"gen_start":9113,"node":26,"role":"declaration","source":0,"src_end":18364,"src_start":17664},{"artifact":1,"gen_end":10335,"gen_start":9680,"node":27,"role":"declaration","source":0,"src_end":20790,"src_start":18370},{"artifact":1,"gen_end":10721,"gen_start":10335,"node":28,"role":"declaration","source":0,"src_end":21559,"src_start":20796},{"artifact":1,"gen_end":11383,"gen_start":10721,"node":29,"role":"declaration","source":0,"src_end":23775,"src_start":21565},{"artifact":1,"gen_end":11783,"gen_start":11383,"node":30,"role":"declaration","source":0,"src_end":24725,"src_start":23781},{"artifact":1,"gen_end":11798,"gen_start":11783,"node":5,"role":"declaration","source":0,"src_end":24781,"src_start":0}],"module":"Main","nodes":[{"id":0,"kind":"tooling-lean-module"},{"id":1,"kind":"tooling-declaration"},{"id":2,"kind":"tooling-declaration"},{"id":3,"kind":"tooling-declaration"},{"id":4,"kind":"tooling-declaration"},{"id":5,"kind":"tooling-latex-module"},{"id":6,"kind":"tooling-declaration"},{"id":7,"kind":"tooling-declaration"},{"id":8,"kind":"tooling-declaration"},{"id":9,"kind":"tooling-declaration"},{"id":10,"kind":"tooling-declaration"},{"id":11,"kind":"tooling-declaration"},{"id":12,"kind":"tooling-declaration"},{"id":13,"kind":"tooling-declaration"},{"id":14,"kind":"tooling-declaration"},{"id":15,"kind":"tooling-declaration"},{"id":16,"kind":"tooling-declaration"},{"id":17,"kind":"tooling-declaration"},{"id":18,"kind":"tooling-declaration"},{"id":19,"kind":"tooling-declaration"},{"id":20,"kind":"tooling-declaration"},{"id":21,"kind":"tooling-declaration"},{"id":22,"kind":"tooling-declaration"},{"id":23,"kind":"tooling-declaration"},{"id":24,"kind":"tooling-declaration"},{"id":25,"kind":"tooling-declaration"},{"id":26,"kind":"tooling-declaration"},{"id":27,"kind":"tooling-declaration"},{"id":28,"kind":"tooling-declaration"},{"id":29,"kind":"tooling-declaration"},{"id":30,"kind":"tooling-declaration"}],"semantic_id":"2c8e8ea9e16647930ec972518ea8b7ca746f951750606bd3eb6c379ecab249cd","source_id":"8245cb4ade3e3746c75f908b8508a34c02ae089662b089b97c444a8c7d62ee79","sources":[{"id":0,"kind":"file","path":"src/Main.lex.tex","sha256":"67110e50b1b9a593a0b92051a0922a3484384db0a1f6845f04b901adf80e81ac"}],"spec":"lexlean/source-map/1"} From 7d8dfdee7088691418a50b28a8f95027229caa1a Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 07:05:54 +0000 Subject: [PATCH 5/6] chore(#161): regenerate bootstrap/ and the records of compiler, stdlib on the merged tree Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- bootstrap/expected/build/manifest.json | 2 +- .../maps/LexLeanBoot/AxiomOutput.map.json | 2 +- .../build/maps/LexLeanBoot/Text.map.json | 2 +- ...ffb1f0a6611d.LexLeanBoot.AxiomOutput.lean} | 0 ...611d.LexLeanBoot.AxiomOutput.process.json} | 2 +- ...e59c5f1ffb1f0a6611d.LexLeanBoot.Text.lean} | 0 ...fb1f0a6611d.LexLeanBoot.Text.process.json} | 2 +- ...1f0a6611d.LexLeanRuntime.Collections.lean} | 0 ...1d.LexLeanRuntime.Collections.process.json | 2 +- ...ffb1f0a6611d.LexLeanRuntime.Portable.lean} | 0 ...6611d.LexLeanRuntime.Portable.process.json | 2 +- ...ct.X5ba510b7049a3e59c5f1ffb1f0a6611d.lean} | 0 .../expected/verify/extract/process.json | 2 +- .../R0.lean | 4 +- .../R0/Compose/RustStd.lex.tex | 24 +++++----- .../R0/RustStd.lean | 4 +- .../R1.lean | 4 +- .../R1/Compose/RustStd.lex.tex | 46 +++++++++---------- .../R1/RustStd.lean | 4 +- bootstrap/expected/verify/preserve/audit.txt | 18 ++++---- .../verify/preserve/preservation.json | 2 +- ...be.P5ba510b7049a3e59c5f1ffb1f0a6611d.lean} | 0 bootstrap/expected/verify/probe/process.json | 2 +- ...59c5f1ffb1f0a6611d.R0.Compose.RustStd.json | 2 +- ...b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json | 2 +- ....C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json | 2 +- ...59c5f1ffb1f0a6611d.R1.Compose.RustStd.json | 2 +- ...b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json | 2 +- ....C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json | 2 +- ...bfc73b1dc6b7a95dab0c348a27.R0.RustStd.json | 1 - ....Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json | 1 - ...bfc73b1dc6b7a95dab0c348a27.R1.RustStd.json | 1 - ....Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json | 1 - .../preserve/LexLeanPreserve.Audit.json | 2 +- ...9c5f1ffb1f0a6611d.R0.Compose.RustStd.json} | 2 +- ...7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json} | 2 +- ....C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json | 1 + ...59c5f1ffb1f0a6611d.R1.Compose.RustStd.json | 2 +- ...7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json} | 2 +- ....C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json | 1 + ....Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json | 1 - ....Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json | 1 - bootstrap/lexlean.lock | 2 +- ...b07a1ff91.LexLeanRuntime.Collections.lean} | 0 ...91.LexLeanRuntime.Collections.process.json | 2 +- ...9a90d88b07a1ff91.LexLeanRuntime.Laws.lean} | 0 ...07a1ff91.LexLeanRuntime.Laws.process.json} | 2 +- ...90d88b07a1ff91.LexLeanRuntime.Models.lean} | 0 ...a1ff91.LexLeanRuntime.Models.process.json} | 2 +- ...d88b07a1ff91.LexLeanRuntime.Portable.lean} | 0 ...ff91.LexLeanRuntime.Portable.process.json} | 2 +- ...88b07a1ff91.LexLeanRuntime.Reasoning.lean} | 0 ...f91.LexLeanRuntime.Reasoning.process.json} | 2 +- ...b07a1ff91.LexLeanTarget.BudgetOracle.lean} | 0 ...1.LexLeanTarget.BudgetOracle.process.json} | 2 +- ...07a1ff91.LexLeanTarget.Certification.lean} | 0 ....LexLeanTarget.Certification.process.json} | 2 +- ...b9a90d88b07a1ff91.LexLeanTarget.Gnaf.lean} | 0 ...b07a1ff91.LexLeanTarget.Gnaf.process.json} | 2 +- ...1ff91.LexLeanTarget.GnafCertificates.lean} | 0 ...xLeanTarget.GnafCertificates.process.json} | 2 +- ...b07a1ff91.LexLeanTarget.GnafFixtures.lean} | 0 ...1.LexLeanTarget.GnafFixtures.process.json} | 2 +- ...8b07a1ff91.LexLeanTarget.GradeOracle.lean} | 0 ...91.LexLeanTarget.GradeOracle.process.json} | 2 +- ...b9a90d88b07a1ff91.LexLeanTarget.Main.lean} | 0 ...b07a1ff91.LexLeanTarget.Main.process.json} | 2 +- ...07a1ff91.LexLeanTarget.PlannerOracle.lean} | 0 ....LexLeanTarget.PlannerOracle.process.json} | 2 +- ...ff91.LexLeanTarget.ReasoningFixtures.lean} | 0 ...LeanTarget.ReasoningFixtures.process.json} | 2 +- ...a1ff91.LexLeanTarget.ReasoningOracle.lean} | 0 ...exLeanTarget.ReasoningOracle.process.json} | 2 +- ...07a1ff91.LexLeanTarget.RustSemantics.lean} | 0 ....LexLeanTarget.RustSemantics.process.json} | 2 +- ...88b07a1ff91.LexLeanTarget.RustSyntax.lean} | 0 ...f91.LexLeanTarget.RustSyntax.process.json} | 2 +- ...a1ff91.LexLeanTarget.ScreeningOracle.lean} | 0 ...exLeanTarget.ScreeningOracle.process.json} | 2 +- ...7a1ff91.LexLeanTarget.TargetFixtures.lean} | 0 ...LexLeanTarget.TargetFixtures.process.json} | 2 +- ...b07a1ff91.LexLeanTarget.TargetOracle.lean} | 0 ...1.LexLeanTarget.TargetOracle.process.json} | 2 +- ...a1ff91.LexLeanTarget.TargetSemantics.lean} | 0 ...exLeanTarget.TargetSemantics.process.json} | 2 +- ...b07a1ff91.LexLeanTarget.TargetSyntax.lean} | 0 ...1.LexLeanTarget.TargetSyntax.process.json} | 2 +- ...be.Pe36982ff9545254b9a90d88b07a1ff91.lean} | 0 compiler/expected/verify/probe/process.json | 2 +- ...7e92c0706.LexLeanRuntime.Collections.lean} | 0 ...6.LexLeanRuntime.Collections.process.json} | 2 +- ...3577e92c0706.LexLeanRuntime.Portable.lean} | 0 ...c0706.LexLeanRuntime.Portable.process.json | 2 +- ...885eb97b3577e92c0706.LexLeanStd.Text.lean} | 0 ...3577e92c0706.LexLeanStd.Text.process.json} | 2 +- ...ct.Xf6fd2434413f885eb97b3577e92c0706.lean} | 0 stdlib/expected/verify/extract/process.json | 2 +- .../R0.lean | 4 +- .../R0/Compose/RustStd.lex.tex | 24 +++++----- .../R0/RustStd.lean | 4 +- .../R1.lean | 4 +- .../R1/Compose/RustStd.lex.tex | 24 +++++----- .../R1/RustStd.lean | 4 +- .../R2.lean | 4 +- .../R2/Compose/RustStd.lex.tex | 24 +++++----- .../R2/RustStd.lean | 4 +- .../R3.lean | 4 +- .../R3/Compose/RustStd.lex.tex | 24 +++++----- .../R3/RustStd.lean | 4 +- .../R4.lean | 4 +- .../R4/Compose/RustStd.lex.tex | 24 +++++----- .../R4/RustStd.lean | 4 +- .../R5.lean | 4 +- .../R5/Compose/RustStd.lex.tex | 24 +++++----- .../R5/RustStd.lean | 4 +- .../R6.lean | 4 +- .../R6/Compose/RustStd.lex.tex | 24 +++++----- .../R6/RustStd.lean | 4 +- stdlib/expected/verify/preserve/audit.txt | 42 ++++++++--------- .../verify/preserve/preservation.json | 2 +- ...be.Pf6fd2434413f885eb97b3577e92c0706.lean} | 0 stdlib/expected/verify/probe/process.json | 2 +- ...d2db2940a1b7735f1309be47dc.R0.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R0.json | 1 - ...d2db2940a1b7735f1309be47dc.R1.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R1.json | 1 - ...a1b7735f1309be47dc.R4.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R4.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R4.json | 1 - ...a1b7735f1309be47dc.R5.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R5.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R5.json | 1 - ...a1b7735f1309be47dc.R6.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R6.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R6.json | 1 - ...5eb97b3577e92c0706.R0.Compose.RustStd.json | 2 +- ...34413f885eb97b3577e92c0706.R0.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R0.json | 1 + ...5eb97b3577e92c0706.R1.Compose.RustStd.json | 2 +- ...34413f885eb97b3577e92c0706.R1.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R1.json | 1 + ...eb97b3577e92c0706.R2.Compose.RustStd.json} | 2 +- ...34413f885eb97b3577e92c0706.R2.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R2.json | 1 + ...eb97b3577e92c0706.R3.Compose.RustStd.json} | 2 +- ...34413f885eb97b3577e92c0706.R3.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R3.json | 1 + ...5eb97b3577e92c0706.R4.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R4.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R4.json | 1 + ...5eb97b3577e92c0706.R5.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R5.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R5.json | 1 + ...5eb97b3577e92c0706.R6.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R6.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R6.json | 1 + .../preserve/LexLeanPreserve.Audit.json | 2 +- ....C5bfc6ad2db2940a1b7735f1309be47dc.R0.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R1.json | 1 - ...a1b7735f1309be47dc.R2.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R2.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R2.json | 1 - ...a1b7735f1309be47dc.R3.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R3.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R3.json | 1 - ...a1b7735f1309be47dc.R4.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R4.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R4.json | 1 - ...a1b7735f1309be47dc.R5.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R5.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R5.json | 1 - ...a1b7735f1309be47dc.R6.Compose.RustStd.json | 1 - ...d2db2940a1b7735f1309be47dc.R6.RustStd.json | 1 - ....C5bfc6ad2db2940a1b7735f1309be47dc.R6.json | 1 - ...eb97b3577e92c0706.R0.Compose.RustStd.json} | 2 +- ...4413f885eb97b3577e92c0706.R0.RustStd.json} | 2 +- ....Cf6fd2434413f885eb97b3577e92c0706.R0.json | 1 + ...5eb97b3577e92c0706.R1.Compose.RustStd.json | 2 +- ...4413f885eb97b3577e92c0706.R1.RustStd.json} | 2 +- ....Cf6fd2434413f885eb97b3577e92c0706.R1.json | 1 + ...5eb97b3577e92c0706.R2.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R2.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R2.json | 1 + ...5eb97b3577e92c0706.R3.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R3.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R3.json | 1 + ...5eb97b3577e92c0706.R4.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R4.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R4.json | 1 + ...5eb97b3577e92c0706.R5.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R5.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R5.json | 1 + ...5eb97b3577e92c0706.R6.Compose.RustStd.json | 1 + ...34413f885eb97b3577e92c0706.R6.RustStd.json | 1 + ....Cf6fd2434413f885eb97b3577e92c0706.R6.json | 1 + .../rust-std/is_closed_lean_name/package.json | 2 +- .../is_closed_lean_name/provenance.json | 2 +- .../rust-std/parse_audit_output/package.json | 2 +- .../parse_audit_output/provenance.json | 2 +- 199 files changed, 285 insertions(+), 285 deletions(-) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.lean => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.lean} (100%) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.process.json => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.process.json} (96%) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.lean => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.lean} (100%) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.process.json => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.process.json} (82%) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.lean => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.lean} (100%) rename compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.process.json => bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.process.json (97%) rename bootstrap/expected/verify/audit/{LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.lean => LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.lean} (100%) rename stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.process.json => bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.process.json (98%) rename bootstrap/expected/verify/extract/{LexLeanExtract.Xadb40bbfc73b1dc6b7a95dab0c348a27.lean => LexLeanExtract.X5ba510b7049a3e59c5f1ffb1f0a6611d.lean} (100%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R0.lean (99%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R0/Compose/RustStd.lex.tex (93%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R0/RustStd.lean (99%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R1.lean (99%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R1/Compose/RustStd.lex.tex (95%) rename bootstrap/expected/verify/preserve/LexLeanPreserve/{Cadb40bbfc73b1dc6b7a95dab0c348a27 => C5ba510b7049a3e59c5f1ffb1f0a6611d}/R1/RustStd.lean (99%) rename bootstrap/expected/verify/probe/{LexLeanProbe.Padb40bbfc73b1dc6b7a95dab0c348a27.lean => LexLeanProbe.P5ba510b7049a3e59c5f1ffb1f0a6611d.lean} (100%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json (72%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json (71%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json (55%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json (72%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json (71%) rename stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json => bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json (55%) delete mode 100644 bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json delete mode 100644 bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json delete mode 100644 bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json delete mode 100644 bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json rename bootstrap/expected/verify/process/preserve/{LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json => LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json} (57%) rename bootstrap/expected/verify/process/preserve/{LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json => LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json} (55%) create mode 100644 bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json rename stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json => bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json (57%) rename bootstrap/expected/verify/process/preserve/{LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json => LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json} (55%) create mode 100644 bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json delete mode 100644 bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json delete mode 100644 bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.lean} (100%) rename bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.process.json => compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.process.json (97%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.process.json} (95%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.process.json} (90%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.process.json} (98%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.process.json} (94%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.process.json} (97%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.process.json} (96%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.process.json} (97%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.process.json} (99%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.process.json} (99%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.process.json} (96%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.process.json} (50%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.process.json} (99%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.process.json} (97%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.process.json} (98%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.process.json} (94%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.process.json} (88%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.process.json} (97%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.process.json} (99%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.process.json} (80%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.process.json} (94%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.lean => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.lean} (100%) rename compiler/expected/verify/audit/{LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.process.json => LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.process.json} (83%) rename compiler/expected/verify/probe/{LexLeanProbe.Pc8f5fdecd4eefbea9d5648c31c7d3f79.lean => LexLeanProbe.Pe36982ff9545254b9a90d88b07a1ff91.lean} (100%) rename stdlib/expected/verify/audit/{LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.lean => LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.lean} (100%) rename stdlib/expected/verify/audit/{LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.process.json => LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.process.json} (97%) rename stdlib/expected/verify/audit/{LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.lean => LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.lean} (100%) rename bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.process.json => stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.process.json (98%) rename stdlib/expected/verify/audit/{LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.lean => LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.lean} (100%) rename stdlib/expected/verify/audit/{LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.process.json => LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.process.json} (82%) rename stdlib/expected/verify/extract/{LexLeanExtract.X5bfc6ad2db2940a1b7735f1309be47dc.lean => LexLeanExtract.Xf6fd2434413f885eb97b3577e92c0706.lean} (100%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R0.lean (97%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R0/Compose/RustStd.lex.tex (94%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R0/RustStd.lean (97%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R1.lean (98%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R1/Compose/RustStd.lex.tex (94%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R1/RustStd.lean (98%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R2.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R2/Compose/RustStd.lex.tex (93%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R2/RustStd.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R3.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R3/Compose/RustStd.lex.tex (94%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R3/RustStd.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R4.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R4/Compose/RustStd.lex.tex (93%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R4/RustStd.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R5.lean (98%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R5/Compose/RustStd.lex.tex (94%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R5/RustStd.lean (98%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R6.lean (99%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R6/Compose/RustStd.lex.tex (94%) rename stdlib/expected/verify/preserve/LexLeanPreserve/{C5bfc6ad2db2940a1b7735f1309be47dc => Cf6fd2434413f885eb97b3577e92c0706}/R6/RustStd.lean (99%) rename stdlib/expected/verify/probe/{LexLeanProbe.P5bfc6ad2db2940a1b7735f1309be47dc.lean => LexLeanProbe.Pf6fd2434413f885eb97b3577e92c0706.lean} (100%) delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json delete mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json rename bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json => stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json (58%) create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json rename bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json => stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json (58%) create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json rename stdlib/expected/verify/process/leanchecker/{LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json => LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json} (58%) create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json rename stdlib/expected/verify/process/leanchecker/{LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json => LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json} (58%) create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json create mode 100644 stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json delete mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json rename stdlib/expected/verify/process/preserve/{LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json => LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json} (57%) rename stdlib/expected/verify/process/preserve/{LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json => LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json} (55%) create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json rename bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json => stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json (57%) rename stdlib/expected/verify/process/preserve/{LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json => LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json} (55%) create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json create mode 100644 stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json diff --git a/bootstrap/expected/build/manifest.json b/bootstrap/expected/build/manifest.json index ad3ffad65..622821b29 100644 --- a/bootstrap/expected/build/manifest.json +++ b/bootstrap/expected/build/manifest.json @@ -1 +1 @@ -{"build_id":"926150e003cfd6aba9deb2efae713e6477fe971dece782542cb30b9eb140fa1d","compiler":{"semantics_id":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"41d45ae532cd8911bf471895ede85deab5002ad61d6d0b646c1bdb013e85b88e"},{"byte_length":649,"kind":"project-config","path":"lexlean.toml","sha256":"7165f2fed5d1b4ece471ea2b9fdbf107c48272617d8bd5d3875f719e2aecc0ef"},{"byte_length":27337,"kind":"source","path":"src/AxiomOutput.lex.tex","sha256":"9f046a50790b9f317a465924703c96839422f20e631a6f6162cc6514955e8567"},{"byte_length":7566,"kind":"source","path":"src/Text.lex.tex","sha256":"2c97a6b06a1c39aa660edc43f366b753175279f9dc99bbea9bb7f900eb1b9a07"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanBoot.AxiomOutput","module":"AxiomOutput","source_path":"src/AxiomOutput.lex.tex"},{"lean_module":"LexLeanBoot.Text","module":"Text","source_path":"src/Text.lex.tex"}],"outputs":[{"byte_length":24570,"kind":"coverage","path":"coverage/LexLeanBoot/AxiomOutput.coverage.json","sha256":"6744a9da2d8960d1c47f4b6eb6a3daeb067b18f762068dbfc001e243edd4305a"},{"byte_length":11380,"kind":"coverage","path":"coverage/LexLeanBoot/Text.coverage.json","sha256":"c0881d9014e5b68860d66a91e8b2c98df6d7eb12ec496e96a61919d213135fbe"},{"byte_length":24423,"kind":"lean","path":"modules/LexLeanBoot/AxiomOutput.lean","sha256":"d20ec2a16744b6e60acf522fdcb0a630aff7fbcab276b9195877dde56a6fb6ec"},{"byte_length":7430,"kind":"lean","path":"modules/LexLeanBoot/Text.lean","sha256":"e8b2e69674901a2cc22df8ed6d57c9ff866a6183af1ca1ea0d9349a9d692774a"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/AxiomOutput.closure.json","sha256":"1c324105489cc204750e32e49064ccecc7492da50c3d06e2cd742f46a2453e49"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Text.closure.json","sha256":"1ad76d0ba0c5e4c958f3593285ad434936f9745f4c422cdd592be86889c16500"},{"byte_length":21662,"kind":"map","path":"maps/LexLeanBoot/AxiomOutput.map.json","sha256":"81a5b4632cb6083019db91800e5305232e3412a215b6926ae33146b9932ad2c1"},{"byte_length":6809,"kind":"map","path":"maps/LexLeanBoot/Text.map.json","sha256":"47bfba5ec052f2bcc66007071e89d8f20d11905f84a45f76bf85d5aa5ff0bd77"},{"byte_length":82621,"kind":"production-eligibility","path":"production/LexLeanBoot/AxiomOutput.eligibility.json","sha256":"2b52cea44f9fd8ee919dd859dd61b3080b169c1beacc08bf659506b40a0967e4"},{"byte_length":41576,"kind":"tex","path":"modules/LexLeanBoot/AxiomOutput.tex","sha256":"ad135d29ad26672ffd88c07d46e3079dc37ba65c78e24ff417171cd09749b7f3"},{"byte_length":12481,"kind":"tex","path":"modules/LexLeanBoot/Text.tex","sha256":"d4de10930e392066953a378eb6d932711017de2316051cc07db8d0f2596722b9"}],"project":"bootstrap","selection":["AxiomOutput","Text"],"semantic_id":"adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb","source_id":"3f41dc0286cbb4e5618c5f0a330c60e2e4f7245869b4343f0b3859285a3d4f7e","spec":"lexlean/build-manifest/1"} +{"build_id":"4dc6de8d0d733053f79e4947163e50ad68f64adc4b3507643cc6790f2fe55431","compiler":{"semantics_id":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","version":"0.3.0"},"inputs":[{"byte_length":2684,"kind":"lexicon","path":"embedded","sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b"},{"byte_length":14885,"kind":"lexicon","path":"embedded","sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac"},{"byte_length":36197,"kind":"lexicon","path":"embedded","sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392"},{"byte_length":1597,"kind":"lock","path":"lexlean.lock","sha256":"88207b13daf7c5b83305e6e6244852f57227a11ae960433f8554cfac69c7a60b"},{"byte_length":649,"kind":"project-config","path":"lexlean.toml","sha256":"7165f2fed5d1b4ece471ea2b9fdbf107c48272617d8bd5d3875f719e2aecc0ef"},{"byte_length":27337,"kind":"source","path":"src/AxiomOutput.lex.tex","sha256":"9f046a50790b9f317a465924703c96839422f20e631a6f6162cc6514955e8567"},{"byte_length":7566,"kind":"source","path":"src/Text.lex.tex","sha256":"2c97a6b06a1c39aa660edc43f366b753175279f9dc99bbea9bb7f900eb1b9a07"}],"language":"1.2","lean_toolchain":"leanprover/lean4:v4.32.1","modules":[{"lean_module":"LexLeanBoot.AxiomOutput","module":"AxiomOutput","source_path":"src/AxiomOutput.lex.tex"},{"lean_module":"LexLeanBoot.Text","module":"Text","source_path":"src/Text.lex.tex"}],"outputs":[{"byte_length":24570,"kind":"coverage","path":"coverage/LexLeanBoot/AxiomOutput.coverage.json","sha256":"6744a9da2d8960d1c47f4b6eb6a3daeb067b18f762068dbfc001e243edd4305a"},{"byte_length":11380,"kind":"coverage","path":"coverage/LexLeanBoot/Text.coverage.json","sha256":"c0881d9014e5b68860d66a91e8b2c98df6d7eb12ec496e96a61919d213135fbe"},{"byte_length":24423,"kind":"lean","path":"modules/LexLeanBoot/AxiomOutput.lean","sha256":"d20ec2a16744b6e60acf522fdcb0a630aff7fbcab276b9195877dde56a6fb6ec"},{"byte_length":7430,"kind":"lean","path":"modules/LexLeanBoot/Text.lean","sha256":"e8b2e69674901a2cc22df8ed6d57c9ff866a6183af1ca1ea0d9349a9d692774a"},{"byte_length":10609,"kind":"lexicon-closure","path":"lexicons/AxiomOutput.closure.json","sha256":"1c324105489cc204750e32e49064ccecc7492da50c3d06e2cd742f46a2453e49"},{"byte_length":10602,"kind":"lexicon-closure","path":"lexicons/Text.closure.json","sha256":"1ad76d0ba0c5e4c958f3593285ad434936f9745f4c422cdd592be86889c16500"},{"byte_length":21662,"kind":"map","path":"maps/LexLeanBoot/AxiomOutput.map.json","sha256":"372a84eaaa1754de94d4e43daa98418b3c0ffb4a1f5c33e6756e6a6aa0448c43"},{"byte_length":6809,"kind":"map","path":"maps/LexLeanBoot/Text.map.json","sha256":"c83503e77bc94eea41bd0f22f4a20515f11b518d3384568faac644e6943cdc51"},{"byte_length":82621,"kind":"production-eligibility","path":"production/LexLeanBoot/AxiomOutput.eligibility.json","sha256":"2b52cea44f9fd8ee919dd859dd61b3080b169c1beacc08bf659506b40a0967e4"},{"byte_length":41576,"kind":"tex","path":"modules/LexLeanBoot/AxiomOutput.tex","sha256":"ad135d29ad26672ffd88c07d46e3079dc37ba65c78e24ff417171cd09749b7f3"},{"byte_length":12481,"kind":"tex","path":"modules/LexLeanBoot/Text.tex","sha256":"d4de10930e392066953a378eb6d932711017de2316051cc07db8d0f2596722b9"}],"project":"bootstrap","selection":["AxiomOutput","Text"],"semantic_id":"5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48","source_id":"d24d87e6939b30919be5d863ae8caee196592ffc1481d8490690c0f435e12acf","spec":"lexlean/build-manifest/1"} diff --git a/bootstrap/expected/build/maps/LexLeanBoot/AxiomOutput.map.json b/bootstrap/expected/build/maps/LexLeanBoot/AxiomOutput.map.json index dad20d792..b19a685ba 100644 --- a/bootstrap/expected/build/maps/LexLeanBoot/AxiomOutput.map.json +++ b/bootstrap/expected/build/maps/LexLeanBoot/AxiomOutput.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanBoot/AxiomOutput.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanBoot/AxiomOutput.tex"}],"mappings":[{"artifact":0,"gen_end":316,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":0,"gen_end":433,"gen_start":316,"node":1,"role":"declaration","source":0,"src_end":346,"src_start":140},{"artifact":0,"gen_end":524,"gen_start":433,"node":2,"role":"declaration","source":0,"src_end":504,"src_start":348},{"artifact":0,"gen_end":731,"gen_start":524,"node":3,"role":"declaration","source":0,"src_end":778,"src_start":506},{"artifact":0,"gen_end":842,"gen_start":731,"node":4,"role":"declaration","source":0,"src_end":921,"src_start":780},{"artifact":0,"gen_end":973,"gen_start":842,"node":5,"role":"declaration","source":0,"src_end":1072,"src_start":923},{"artifact":0,"gen_end":1079,"gen_start":973,"node":6,"role":"declaration","source":0,"src_end":1217,"src_start":1074},{"artifact":0,"gen_end":1257,"gen_start":1079,"node":7,"role":"declaration","source":0,"src_end":1441,"src_start":1219},{"artifact":0,"gen_end":1479,"gen_start":1257,"node":8,"role":"declaration","source":0,"src_end":1708,"src_start":1443},{"artifact":0,"gen_end":1647,"gen_start":1479,"node":9,"role":"declaration","source":0,"src_end":1921,"src_start":1710},{"artifact":0,"gen_end":1852,"gen_start":1647,"node":10,"role":"declaration","source":0,"src_end":2197,"src_start":1923},{"artifact":0,"gen_end":2178,"gen_start":1852,"node":11,"role":"declaration","source":0,"src_end":2597,"src_start":2199},{"artifact":0,"gen_end":2416,"gen_start":2178,"node":12,"role":"declaration","source":0,"src_end":2897,"src_start":2599},{"artifact":0,"gen_end":2695,"gen_start":2416,"node":13,"role":"declaration","source":0,"src_end":3228,"src_start":2899},{"artifact":0,"gen_end":3012,"gen_start":2695,"node":14,"role":"declaration","source":0,"src_end":3587,"src_start":3230},{"artifact":0,"gen_end":3351,"gen_start":3012,"node":15,"role":"declaration","source":0,"src_end":4049,"src_start":3589},{"artifact":0,"gen_end":3623,"gen_start":3351,"node":16,"role":"declaration","source":0,"src_end":4434,"src_start":4051},{"artifact":0,"gen_end":3865,"gen_start":3623,"node":17,"role":"declaration","source":0,"src_end":4697,"src_start":4436},{"artifact":0,"gen_end":4103,"gen_start":3865,"node":18,"role":"declaration","source":0,"src_end":4998,"src_start":4699},{"artifact":0,"gen_end":5635,"gen_start":4103,"node":19,"role":"declaration","source":0,"src_end":6529,"src_start":5000},{"artifact":0,"gen_end":6158,"gen_start":5635,"node":20,"role":"declaration","source":0,"src_end":7003,"src_start":6531},{"artifact":0,"gen_end":6266,"gen_start":6158,"node":21,"role":"declaration","source":0,"src_end":7180,"src_start":7005},{"artifact":0,"gen_end":6599,"gen_start":6266,"node":22,"role":"declaration","source":0,"src_end":7580,"src_start":7182},{"artifact":0,"gen_end":7100,"gen_start":6599,"node":23,"role":"declaration","source":0,"src_end":8094,"src_start":7582},{"artifact":0,"gen_end":7359,"gen_start":7100,"node":24,"role":"declaration","source":0,"src_end":8390,"src_start":8096},{"artifact":0,"gen_end":7757,"gen_start":7359,"node":25,"role":"declaration","source":0,"src_end":8760,"src_start":8392},{"artifact":0,"gen_end":8100,"gen_start":7757,"node":26,"role":"declaration","source":0,"src_end":9103,"src_start":8762},{"artifact":0,"gen_end":8627,"gen_start":8100,"node":27,"role":"declaration","source":0,"src_end":9615,"src_start":9105},{"artifact":0,"gen_end":8931,"gen_start":8627,"node":28,"role":"declaration","source":0,"src_end":9959,"src_start":9617},{"artifact":0,"gen_end":9706,"gen_start":8931,"node":29,"role":"declaration","source":0,"src_end":10720,"src_start":9961},{"artifact":0,"gen_end":9909,"gen_start":9706,"node":30,"role":"declaration","source":0,"src_end":11020,"src_start":10722},{"artifact":0,"gen_end":10192,"gen_start":9909,"node":31,"role":"declaration","source":0,"src_end":11336,"src_start":11022},{"artifact":0,"gen_end":10379,"gen_start":10192,"node":32,"role":"declaration","source":0,"src_end":11589,"src_start":11338},{"artifact":0,"gen_end":10758,"gen_start":10379,"node":33,"role":"declaration","source":0,"src_end":11943,"src_start":11591},{"artifact":0,"gen_end":10980,"gen_start":10758,"node":34,"role":"declaration","source":0,"src_end":12164,"src_start":11945},{"artifact":0,"gen_end":12501,"gen_start":10980,"node":35,"role":"declaration","source":0,"src_end":13333,"src_start":12166},{"artifact":0,"gen_end":12916,"gen_start":12501,"node":36,"role":"declaration","source":0,"src_end":13711,"src_start":13335},{"artifact":0,"gen_end":13277,"gen_start":12916,"node":37,"role":"declaration","source":0,"src_end":14128,"src_start":13713},{"artifact":0,"gen_end":13362,"gen_start":13277,"node":38,"role":"declaration","source":0,"src_end":14293,"src_start":14130},{"artifact":0,"gen_end":13575,"gen_start":13362,"node":39,"role":"declaration","source":0,"src_end":14563,"src_start":14295},{"artifact":0,"gen_end":14311,"gen_start":13575,"node":40,"role":"declaration","source":0,"src_end":15445,"src_start":14565},{"artifact":0,"gen_end":14933,"gen_start":14311,"node":41,"role":"declaration","source":0,"src_end":16223,"src_start":15447},{"artifact":0,"gen_end":15218,"gen_start":14933,"node":42,"role":"declaration","source":0,"src_end":16598,"src_start":16225},{"artifact":0,"gen_end":15496,"gen_start":15218,"node":43,"role":"declaration","source":0,"src_end":16944,"src_start":16600},{"artifact":0,"gen_end":15747,"gen_start":15496,"node":44,"role":"declaration","source":0,"src_end":17191,"src_start":16946},{"artifact":0,"gen_end":16249,"gen_start":15747,"node":45,"role":"declaration","source":0,"src_end":17873,"src_start":17193},{"artifact":0,"gen_end":16912,"gen_start":16249,"node":46,"role":"declaration","source":0,"src_end":18754,"src_start":17875},{"artifact":0,"gen_end":17027,"gen_start":16912,"node":47,"role":"declaration","source":0,"src_end":18910,"src_start":18756},{"artifact":0,"gen_end":17194,"gen_start":17027,"node":48,"role":"declaration","source":0,"src_end":19135,"src_start":18912},{"artifact":0,"gen_end":17335,"gen_start":17194,"node":49,"role":"declaration","source":0,"src_end":19339,"src_start":19137},{"artifact":0,"gen_end":17522,"gen_start":17335,"node":50,"role":"declaration","source":0,"src_end":19550,"src_start":19341},{"artifact":0,"gen_end":18024,"gen_start":17522,"node":51,"role":"declaration","source":0,"src_end":20200,"src_start":19552},{"artifact":0,"gen_end":18630,"gen_start":18024,"node":52,"role":"declaration","source":0,"src_end":20831,"src_start":20202},{"artifact":0,"gen_end":19241,"gen_start":18630,"node":53,"role":"declaration","source":0,"src_end":21454,"src_start":20833},{"artifact":0,"gen_end":19999,"gen_start":19241,"node":54,"role":"declaration","source":0,"src_end":22228,"src_start":21456},{"artifact":0,"gen_end":20165,"gen_start":19999,"node":55,"role":"declaration","source":0,"src_end":22471,"src_start":22230},{"artifact":0,"gen_end":20327,"gen_start":20165,"node":56,"role":"declaration","source":0,"src_end":22662,"src_start":22473},{"artifact":0,"gen_end":20469,"gen_start":20327,"node":57,"role":"declaration","source":0,"src_end":22849,"src_start":22664},{"artifact":0,"gen_end":20939,"gen_start":20469,"node":58,"role":"declaration","source":0,"src_end":23425,"src_start":22851},{"artifact":0,"gen_end":21213,"gen_start":20939,"node":59,"role":"declaration","source":0,"src_end":23793,"src_start":23427},{"artifact":0,"gen_end":21949,"gen_start":21213,"node":60,"role":"declaration","source":0,"src_end":24592,"src_start":23795},{"artifact":0,"gen_end":22982,"gen_start":21949,"node":61,"role":"declaration","source":0,"src_end":25727,"src_start":24594},{"artifact":0,"gen_end":24024,"gen_start":22982,"node":62,"role":"declaration","source":0,"src_end":26835,"src_start":25729},{"artifact":0,"gen_end":24394,"gen_start":24024,"node":63,"role":"declaration","source":0,"src_end":27301,"src_start":26837},{"artifact":0,"gen_end":24423,"gen_start":24394,"node":0,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":64,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":1,"gen_end":398,"gen_start":134,"node":65,"role":"declaration","source":0,"src_end":346,"src_start":140},{"artifact":1,"gen_end":600,"gen_start":398,"node":66,"role":"declaration","source":0,"src_end":504,"src_start":348},{"artifact":1,"gen_end":940,"gen_start":600,"node":67,"role":"declaration","source":0,"src_end":778,"src_start":506},{"artifact":1,"gen_end":1298,"gen_start":940,"node":68,"role":"declaration","source":0,"src_end":921,"src_start":780},{"artifact":1,"gen_end":1676,"gen_start":1298,"node":69,"role":"declaration","source":0,"src_end":1072,"src_start":923},{"artifact":1,"gen_end":2029,"gen_start":1676,"node":70,"role":"declaration","source":0,"src_end":1217,"src_start":1074},{"artifact":1,"gen_end":2566,"gen_start":2029,"node":71,"role":"declaration","source":0,"src_end":1441,"src_start":1219},{"artifact":1,"gen_end":3147,"gen_start":2566,"node":72,"role":"declaration","source":0,"src_end":1708,"src_start":1443},{"artifact":1,"gen_end":3564,"gen_start":3147,"node":73,"role":"declaration","source":0,"src_end":1921,"src_start":1710},{"artifact":1,"gen_end":4016,"gen_start":3564,"node":74,"role":"declaration","source":0,"src_end":2197,"src_start":1923},{"artifact":1,"gen_end":4614,"gen_start":4016,"node":75,"role":"declaration","source":0,"src_end":2597,"src_start":2199},{"artifact":1,"gen_end":5122,"gen_start":4614,"node":76,"role":"declaration","source":0,"src_end":2897,"src_start":2599},{"artifact":1,"gen_end":5671,"gen_start":5122,"node":77,"role":"declaration","source":0,"src_end":3228,"src_start":2899},{"artifact":1,"gen_end":6258,"gen_start":5671,"node":78,"role":"declaration","source":0,"src_end":3587,"src_start":3230},{"artifact":1,"gen_end":6867,"gen_start":6258,"node":79,"role":"declaration","source":0,"src_end":4049,"src_start":3589},{"artifact":1,"gen_end":7604,"gen_start":6867,"node":80,"role":"declaration","source":0,"src_end":4434,"src_start":4051},{"artifact":1,"gen_end":8093,"gen_start":7604,"node":81,"role":"declaration","source":0,"src_end":4697,"src_start":4436},{"artifact":1,"gen_end":8601,"gen_start":8093,"node":82,"role":"declaration","source":0,"src_end":4998,"src_start":4699},{"artifact":1,"gen_end":10403,"gen_start":8601,"node":83,"role":"declaration","source":0,"src_end":6529,"src_start":5000},{"artifact":1,"gen_end":11280,"gen_start":10403,"node":84,"role":"declaration","source":0,"src_end":7003,"src_start":6531},{"artifact":1,"gen_end":11658,"gen_start":11280,"node":85,"role":"declaration","source":0,"src_end":7180,"src_start":7005},{"artifact":1,"gen_end":12342,"gen_start":11658,"node":86,"role":"declaration","source":0,"src_end":7580,"src_start":7182},{"artifact":1,"gen_end":13268,"gen_start":12342,"node":87,"role":"declaration","source":0,"src_end":8094,"src_start":7582},{"artifact":1,"gen_end":13821,"gen_start":13268,"node":88,"role":"declaration","source":0,"src_end":8390,"src_start":8096},{"artifact":1,"gen_end":14514,"gen_start":13821,"node":89,"role":"declaration","source":0,"src_end":8760,"src_start":8392},{"artifact":1,"gen_end":15104,"gen_start":14514,"node":90,"role":"declaration","source":0,"src_end":9103,"src_start":8762},{"artifact":1,"gen_end":15878,"gen_start":15104,"node":91,"role":"declaration","source":0,"src_end":9615,"src_start":9105},{"artifact":1,"gen_end":16429,"gen_start":15878,"node":92,"role":"declaration","source":0,"src_end":9959,"src_start":9617},{"artifact":1,"gen_end":17540,"gen_start":16429,"node":93,"role":"declaration","source":0,"src_end":10720,"src_start":9961},{"artifact":1,"gen_end":18013,"gen_start":17540,"node":94,"role":"declaration","source":0,"src_end":11020,"src_start":10722},{"artifact":1,"gen_end":18647,"gen_start":18013,"node":95,"role":"declaration","source":0,"src_end":11336,"src_start":11022},{"artifact":1,"gen_end":19081,"gen_start":18647,"node":96,"role":"declaration","source":0,"src_end":11589,"src_start":11338},{"artifact":1,"gen_end":19787,"gen_start":19081,"node":97,"role":"declaration","source":0,"src_end":11943,"src_start":11591},{"artifact":1,"gen_end":20256,"gen_start":19787,"node":98,"role":"declaration","source":0,"src_end":12164,"src_start":11945},{"artifact":1,"gen_end":22024,"gen_start":20256,"node":99,"role":"declaration","source":0,"src_end":13333,"src_start":12166},{"artifact":1,"gen_end":22699,"gen_start":22024,"node":100,"role":"declaration","source":0,"src_end":13711,"src_start":13335},{"artifact":1,"gen_end":23330,"gen_start":22699,"node":101,"role":"declaration","source":0,"src_end":14128,"src_start":13713},{"artifact":1,"gen_end":23685,"gen_start":23330,"node":102,"role":"declaration","source":0,"src_end":14293,"src_start":14130},{"artifact":1,"gen_end":24145,"gen_start":23685,"node":103,"role":"declaration","source":0,"src_end":14563,"src_start":14295},{"artifact":1,"gen_end":25153,"gen_start":24145,"node":104,"role":"declaration","source":0,"src_end":15445,"src_start":14565},{"artifact":1,"gen_end":26049,"gen_start":25153,"node":105,"role":"declaration","source":0,"src_end":16223,"src_start":15447},{"artifact":1,"gen_end":26604,"gen_start":26049,"node":106,"role":"declaration","source":0,"src_end":16598,"src_start":16225},{"artifact":1,"gen_end":27131,"gen_start":26604,"node":107,"role":"declaration","source":0,"src_end":16944,"src_start":16600},{"artifact":1,"gen_end":27642,"gen_start":27131,"node":108,"role":"declaration","source":0,"src_end":17191,"src_start":16946},{"artifact":1,"gen_end":28401,"gen_start":27642,"node":109,"role":"declaration","source":0,"src_end":17873,"src_start":17193},{"artifact":1,"gen_end":29305,"gen_start":28401,"node":110,"role":"declaration","source":0,"src_end":18754,"src_start":17875},{"artifact":1,"gen_end":29667,"gen_start":29305,"node":111,"role":"declaration","source":0,"src_end":18910,"src_start":18756},{"artifact":1,"gen_end":30081,"gen_start":29667,"node":112,"role":"declaration","source":0,"src_end":19135,"src_start":18912},{"artifact":1,"gen_end":30469,"gen_start":30081,"node":113,"role":"declaration","source":0,"src_end":19339,"src_start":19137},{"artifact":1,"gen_end":30903,"gen_start":30469,"node":114,"role":"declaration","source":0,"src_end":19550,"src_start":19341},{"artifact":1,"gen_end":31676,"gen_start":30903,"node":115,"role":"declaration","source":0,"src_end":20200,"src_start":19552},{"artifact":1,"gen_end":32632,"gen_start":31676,"node":116,"role":"declaration","source":0,"src_end":20831,"src_start":20202},{"artifact":1,"gen_end":33515,"gen_start":32632,"node":117,"role":"declaration","source":0,"src_end":21454,"src_start":20833},{"artifact":1,"gen_end":34543,"gen_start":33515,"node":118,"role":"declaration","source":0,"src_end":22228,"src_start":21456},{"artifact":1,"gen_end":34957,"gen_start":34543,"node":119,"role":"declaration","source":0,"src_end":22471,"src_start":22230},{"artifact":1,"gen_end":35367,"gen_start":34957,"node":120,"role":"declaration","source":0,"src_end":22662,"src_start":22473},{"artifact":1,"gen_end":35756,"gen_start":35367,"node":121,"role":"declaration","source":0,"src_end":22849,"src_start":22664},{"artifact":1,"gen_end":36498,"gen_start":35756,"node":122,"role":"declaration","source":0,"src_end":23425,"src_start":22851},{"artifact":1,"gen_end":37042,"gen_start":36498,"node":123,"role":"declaration","source":0,"src_end":23793,"src_start":23427},{"artifact":1,"gen_end":38049,"gen_start":37042,"node":124,"role":"declaration","source":0,"src_end":24592,"src_start":23795},{"artifact":1,"gen_end":39342,"gen_start":38049,"node":125,"role":"declaration","source":0,"src_end":25727,"src_start":24594},{"artifact":1,"gen_end":40723,"gen_start":39342,"node":126,"role":"declaration","source":0,"src_end":26835,"src_start":25729},{"artifact":1,"gen_end":41561,"gen_start":40723,"node":127,"role":"declaration","source":0,"src_end":27301,"src_start":26837},{"artifact":1,"gen_end":41576,"gen_start":41561,"node":64,"role":"declaration","source":0,"src_end":27337,"src_start":0}],"module":"AxiomOutput","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-latex-module"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"}],"semantic_id":"adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb","source_id":"3f41dc0286cbb4e5618c5f0a330c60e2e4f7245869b4343f0b3859285a3d4f7e","sources":[{"id":0,"kind":"file","path":"src/AxiomOutput.lex.tex","sha256":"9f046a50790b9f317a465924703c96839422f20e631a6f6162cc6514955e8567"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanBoot/AxiomOutput.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanBoot/AxiomOutput.tex"}],"mappings":[{"artifact":0,"gen_end":316,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":0,"gen_end":433,"gen_start":316,"node":1,"role":"declaration","source":0,"src_end":346,"src_start":140},{"artifact":0,"gen_end":524,"gen_start":433,"node":2,"role":"declaration","source":0,"src_end":504,"src_start":348},{"artifact":0,"gen_end":731,"gen_start":524,"node":3,"role":"declaration","source":0,"src_end":778,"src_start":506},{"artifact":0,"gen_end":842,"gen_start":731,"node":4,"role":"declaration","source":0,"src_end":921,"src_start":780},{"artifact":0,"gen_end":973,"gen_start":842,"node":5,"role":"declaration","source":0,"src_end":1072,"src_start":923},{"artifact":0,"gen_end":1079,"gen_start":973,"node":6,"role":"declaration","source":0,"src_end":1217,"src_start":1074},{"artifact":0,"gen_end":1257,"gen_start":1079,"node":7,"role":"declaration","source":0,"src_end":1441,"src_start":1219},{"artifact":0,"gen_end":1479,"gen_start":1257,"node":8,"role":"declaration","source":0,"src_end":1708,"src_start":1443},{"artifact":0,"gen_end":1647,"gen_start":1479,"node":9,"role":"declaration","source":0,"src_end":1921,"src_start":1710},{"artifact":0,"gen_end":1852,"gen_start":1647,"node":10,"role":"declaration","source":0,"src_end":2197,"src_start":1923},{"artifact":0,"gen_end":2178,"gen_start":1852,"node":11,"role":"declaration","source":0,"src_end":2597,"src_start":2199},{"artifact":0,"gen_end":2416,"gen_start":2178,"node":12,"role":"declaration","source":0,"src_end":2897,"src_start":2599},{"artifact":0,"gen_end":2695,"gen_start":2416,"node":13,"role":"declaration","source":0,"src_end":3228,"src_start":2899},{"artifact":0,"gen_end":3012,"gen_start":2695,"node":14,"role":"declaration","source":0,"src_end":3587,"src_start":3230},{"artifact":0,"gen_end":3351,"gen_start":3012,"node":15,"role":"declaration","source":0,"src_end":4049,"src_start":3589},{"artifact":0,"gen_end":3623,"gen_start":3351,"node":16,"role":"declaration","source":0,"src_end":4434,"src_start":4051},{"artifact":0,"gen_end":3865,"gen_start":3623,"node":17,"role":"declaration","source":0,"src_end":4697,"src_start":4436},{"artifact":0,"gen_end":4103,"gen_start":3865,"node":18,"role":"declaration","source":0,"src_end":4998,"src_start":4699},{"artifact":0,"gen_end":5635,"gen_start":4103,"node":19,"role":"declaration","source":0,"src_end":6529,"src_start":5000},{"artifact":0,"gen_end":6158,"gen_start":5635,"node":20,"role":"declaration","source":0,"src_end":7003,"src_start":6531},{"artifact":0,"gen_end":6266,"gen_start":6158,"node":21,"role":"declaration","source":0,"src_end":7180,"src_start":7005},{"artifact":0,"gen_end":6599,"gen_start":6266,"node":22,"role":"declaration","source":0,"src_end":7580,"src_start":7182},{"artifact":0,"gen_end":7100,"gen_start":6599,"node":23,"role":"declaration","source":0,"src_end":8094,"src_start":7582},{"artifact":0,"gen_end":7359,"gen_start":7100,"node":24,"role":"declaration","source":0,"src_end":8390,"src_start":8096},{"artifact":0,"gen_end":7757,"gen_start":7359,"node":25,"role":"declaration","source":0,"src_end":8760,"src_start":8392},{"artifact":0,"gen_end":8100,"gen_start":7757,"node":26,"role":"declaration","source":0,"src_end":9103,"src_start":8762},{"artifact":0,"gen_end":8627,"gen_start":8100,"node":27,"role":"declaration","source":0,"src_end":9615,"src_start":9105},{"artifact":0,"gen_end":8931,"gen_start":8627,"node":28,"role":"declaration","source":0,"src_end":9959,"src_start":9617},{"artifact":0,"gen_end":9706,"gen_start":8931,"node":29,"role":"declaration","source":0,"src_end":10720,"src_start":9961},{"artifact":0,"gen_end":9909,"gen_start":9706,"node":30,"role":"declaration","source":0,"src_end":11020,"src_start":10722},{"artifact":0,"gen_end":10192,"gen_start":9909,"node":31,"role":"declaration","source":0,"src_end":11336,"src_start":11022},{"artifact":0,"gen_end":10379,"gen_start":10192,"node":32,"role":"declaration","source":0,"src_end":11589,"src_start":11338},{"artifact":0,"gen_end":10758,"gen_start":10379,"node":33,"role":"declaration","source":0,"src_end":11943,"src_start":11591},{"artifact":0,"gen_end":10980,"gen_start":10758,"node":34,"role":"declaration","source":0,"src_end":12164,"src_start":11945},{"artifact":0,"gen_end":12501,"gen_start":10980,"node":35,"role":"declaration","source":0,"src_end":13333,"src_start":12166},{"artifact":0,"gen_end":12916,"gen_start":12501,"node":36,"role":"declaration","source":0,"src_end":13711,"src_start":13335},{"artifact":0,"gen_end":13277,"gen_start":12916,"node":37,"role":"declaration","source":0,"src_end":14128,"src_start":13713},{"artifact":0,"gen_end":13362,"gen_start":13277,"node":38,"role":"declaration","source":0,"src_end":14293,"src_start":14130},{"artifact":0,"gen_end":13575,"gen_start":13362,"node":39,"role":"declaration","source":0,"src_end":14563,"src_start":14295},{"artifact":0,"gen_end":14311,"gen_start":13575,"node":40,"role":"declaration","source":0,"src_end":15445,"src_start":14565},{"artifact":0,"gen_end":14933,"gen_start":14311,"node":41,"role":"declaration","source":0,"src_end":16223,"src_start":15447},{"artifact":0,"gen_end":15218,"gen_start":14933,"node":42,"role":"declaration","source":0,"src_end":16598,"src_start":16225},{"artifact":0,"gen_end":15496,"gen_start":15218,"node":43,"role":"declaration","source":0,"src_end":16944,"src_start":16600},{"artifact":0,"gen_end":15747,"gen_start":15496,"node":44,"role":"declaration","source":0,"src_end":17191,"src_start":16946},{"artifact":0,"gen_end":16249,"gen_start":15747,"node":45,"role":"declaration","source":0,"src_end":17873,"src_start":17193},{"artifact":0,"gen_end":16912,"gen_start":16249,"node":46,"role":"declaration","source":0,"src_end":18754,"src_start":17875},{"artifact":0,"gen_end":17027,"gen_start":16912,"node":47,"role":"declaration","source":0,"src_end":18910,"src_start":18756},{"artifact":0,"gen_end":17194,"gen_start":17027,"node":48,"role":"declaration","source":0,"src_end":19135,"src_start":18912},{"artifact":0,"gen_end":17335,"gen_start":17194,"node":49,"role":"declaration","source":0,"src_end":19339,"src_start":19137},{"artifact":0,"gen_end":17522,"gen_start":17335,"node":50,"role":"declaration","source":0,"src_end":19550,"src_start":19341},{"artifact":0,"gen_end":18024,"gen_start":17522,"node":51,"role":"declaration","source":0,"src_end":20200,"src_start":19552},{"artifact":0,"gen_end":18630,"gen_start":18024,"node":52,"role":"declaration","source":0,"src_end":20831,"src_start":20202},{"artifact":0,"gen_end":19241,"gen_start":18630,"node":53,"role":"declaration","source":0,"src_end":21454,"src_start":20833},{"artifact":0,"gen_end":19999,"gen_start":19241,"node":54,"role":"declaration","source":0,"src_end":22228,"src_start":21456},{"artifact":0,"gen_end":20165,"gen_start":19999,"node":55,"role":"declaration","source":0,"src_end":22471,"src_start":22230},{"artifact":0,"gen_end":20327,"gen_start":20165,"node":56,"role":"declaration","source":0,"src_end":22662,"src_start":22473},{"artifact":0,"gen_end":20469,"gen_start":20327,"node":57,"role":"declaration","source":0,"src_end":22849,"src_start":22664},{"artifact":0,"gen_end":20939,"gen_start":20469,"node":58,"role":"declaration","source":0,"src_end":23425,"src_start":22851},{"artifact":0,"gen_end":21213,"gen_start":20939,"node":59,"role":"declaration","source":0,"src_end":23793,"src_start":23427},{"artifact":0,"gen_end":21949,"gen_start":21213,"node":60,"role":"declaration","source":0,"src_end":24592,"src_start":23795},{"artifact":0,"gen_end":22982,"gen_start":21949,"node":61,"role":"declaration","source":0,"src_end":25727,"src_start":24594},{"artifact":0,"gen_end":24024,"gen_start":22982,"node":62,"role":"declaration","source":0,"src_end":26835,"src_start":25729},{"artifact":0,"gen_end":24394,"gen_start":24024,"node":63,"role":"declaration","source":0,"src_end":27301,"src_start":26837},{"artifact":0,"gen_end":24423,"gen_start":24394,"node":0,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":64,"role":"declaration","source":0,"src_end":27337,"src_start":0},{"artifact":1,"gen_end":398,"gen_start":134,"node":65,"role":"declaration","source":0,"src_end":346,"src_start":140},{"artifact":1,"gen_end":600,"gen_start":398,"node":66,"role":"declaration","source":0,"src_end":504,"src_start":348},{"artifact":1,"gen_end":940,"gen_start":600,"node":67,"role":"declaration","source":0,"src_end":778,"src_start":506},{"artifact":1,"gen_end":1298,"gen_start":940,"node":68,"role":"declaration","source":0,"src_end":921,"src_start":780},{"artifact":1,"gen_end":1676,"gen_start":1298,"node":69,"role":"declaration","source":0,"src_end":1072,"src_start":923},{"artifact":1,"gen_end":2029,"gen_start":1676,"node":70,"role":"declaration","source":0,"src_end":1217,"src_start":1074},{"artifact":1,"gen_end":2566,"gen_start":2029,"node":71,"role":"declaration","source":0,"src_end":1441,"src_start":1219},{"artifact":1,"gen_end":3147,"gen_start":2566,"node":72,"role":"declaration","source":0,"src_end":1708,"src_start":1443},{"artifact":1,"gen_end":3564,"gen_start":3147,"node":73,"role":"declaration","source":0,"src_end":1921,"src_start":1710},{"artifact":1,"gen_end":4016,"gen_start":3564,"node":74,"role":"declaration","source":0,"src_end":2197,"src_start":1923},{"artifact":1,"gen_end":4614,"gen_start":4016,"node":75,"role":"declaration","source":0,"src_end":2597,"src_start":2199},{"artifact":1,"gen_end":5122,"gen_start":4614,"node":76,"role":"declaration","source":0,"src_end":2897,"src_start":2599},{"artifact":1,"gen_end":5671,"gen_start":5122,"node":77,"role":"declaration","source":0,"src_end":3228,"src_start":2899},{"artifact":1,"gen_end":6258,"gen_start":5671,"node":78,"role":"declaration","source":0,"src_end":3587,"src_start":3230},{"artifact":1,"gen_end":6867,"gen_start":6258,"node":79,"role":"declaration","source":0,"src_end":4049,"src_start":3589},{"artifact":1,"gen_end":7604,"gen_start":6867,"node":80,"role":"declaration","source":0,"src_end":4434,"src_start":4051},{"artifact":1,"gen_end":8093,"gen_start":7604,"node":81,"role":"declaration","source":0,"src_end":4697,"src_start":4436},{"artifact":1,"gen_end":8601,"gen_start":8093,"node":82,"role":"declaration","source":0,"src_end":4998,"src_start":4699},{"artifact":1,"gen_end":10403,"gen_start":8601,"node":83,"role":"declaration","source":0,"src_end":6529,"src_start":5000},{"artifact":1,"gen_end":11280,"gen_start":10403,"node":84,"role":"declaration","source":0,"src_end":7003,"src_start":6531},{"artifact":1,"gen_end":11658,"gen_start":11280,"node":85,"role":"declaration","source":0,"src_end":7180,"src_start":7005},{"artifact":1,"gen_end":12342,"gen_start":11658,"node":86,"role":"declaration","source":0,"src_end":7580,"src_start":7182},{"artifact":1,"gen_end":13268,"gen_start":12342,"node":87,"role":"declaration","source":0,"src_end":8094,"src_start":7582},{"artifact":1,"gen_end":13821,"gen_start":13268,"node":88,"role":"declaration","source":0,"src_end":8390,"src_start":8096},{"artifact":1,"gen_end":14514,"gen_start":13821,"node":89,"role":"declaration","source":0,"src_end":8760,"src_start":8392},{"artifact":1,"gen_end":15104,"gen_start":14514,"node":90,"role":"declaration","source":0,"src_end":9103,"src_start":8762},{"artifact":1,"gen_end":15878,"gen_start":15104,"node":91,"role":"declaration","source":0,"src_end":9615,"src_start":9105},{"artifact":1,"gen_end":16429,"gen_start":15878,"node":92,"role":"declaration","source":0,"src_end":9959,"src_start":9617},{"artifact":1,"gen_end":17540,"gen_start":16429,"node":93,"role":"declaration","source":0,"src_end":10720,"src_start":9961},{"artifact":1,"gen_end":18013,"gen_start":17540,"node":94,"role":"declaration","source":0,"src_end":11020,"src_start":10722},{"artifact":1,"gen_end":18647,"gen_start":18013,"node":95,"role":"declaration","source":0,"src_end":11336,"src_start":11022},{"artifact":1,"gen_end":19081,"gen_start":18647,"node":96,"role":"declaration","source":0,"src_end":11589,"src_start":11338},{"artifact":1,"gen_end":19787,"gen_start":19081,"node":97,"role":"declaration","source":0,"src_end":11943,"src_start":11591},{"artifact":1,"gen_end":20256,"gen_start":19787,"node":98,"role":"declaration","source":0,"src_end":12164,"src_start":11945},{"artifact":1,"gen_end":22024,"gen_start":20256,"node":99,"role":"declaration","source":0,"src_end":13333,"src_start":12166},{"artifact":1,"gen_end":22699,"gen_start":22024,"node":100,"role":"declaration","source":0,"src_end":13711,"src_start":13335},{"artifact":1,"gen_end":23330,"gen_start":22699,"node":101,"role":"declaration","source":0,"src_end":14128,"src_start":13713},{"artifact":1,"gen_end":23685,"gen_start":23330,"node":102,"role":"declaration","source":0,"src_end":14293,"src_start":14130},{"artifact":1,"gen_end":24145,"gen_start":23685,"node":103,"role":"declaration","source":0,"src_end":14563,"src_start":14295},{"artifact":1,"gen_end":25153,"gen_start":24145,"node":104,"role":"declaration","source":0,"src_end":15445,"src_start":14565},{"artifact":1,"gen_end":26049,"gen_start":25153,"node":105,"role":"declaration","source":0,"src_end":16223,"src_start":15447},{"artifact":1,"gen_end":26604,"gen_start":26049,"node":106,"role":"declaration","source":0,"src_end":16598,"src_start":16225},{"artifact":1,"gen_end":27131,"gen_start":26604,"node":107,"role":"declaration","source":0,"src_end":16944,"src_start":16600},{"artifact":1,"gen_end":27642,"gen_start":27131,"node":108,"role":"declaration","source":0,"src_end":17191,"src_start":16946},{"artifact":1,"gen_end":28401,"gen_start":27642,"node":109,"role":"declaration","source":0,"src_end":17873,"src_start":17193},{"artifact":1,"gen_end":29305,"gen_start":28401,"node":110,"role":"declaration","source":0,"src_end":18754,"src_start":17875},{"artifact":1,"gen_end":29667,"gen_start":29305,"node":111,"role":"declaration","source":0,"src_end":18910,"src_start":18756},{"artifact":1,"gen_end":30081,"gen_start":29667,"node":112,"role":"declaration","source":0,"src_end":19135,"src_start":18912},{"artifact":1,"gen_end":30469,"gen_start":30081,"node":113,"role":"declaration","source":0,"src_end":19339,"src_start":19137},{"artifact":1,"gen_end":30903,"gen_start":30469,"node":114,"role":"declaration","source":0,"src_end":19550,"src_start":19341},{"artifact":1,"gen_end":31676,"gen_start":30903,"node":115,"role":"declaration","source":0,"src_end":20200,"src_start":19552},{"artifact":1,"gen_end":32632,"gen_start":31676,"node":116,"role":"declaration","source":0,"src_end":20831,"src_start":20202},{"artifact":1,"gen_end":33515,"gen_start":32632,"node":117,"role":"declaration","source":0,"src_end":21454,"src_start":20833},{"artifact":1,"gen_end":34543,"gen_start":33515,"node":118,"role":"declaration","source":0,"src_end":22228,"src_start":21456},{"artifact":1,"gen_end":34957,"gen_start":34543,"node":119,"role":"declaration","source":0,"src_end":22471,"src_start":22230},{"artifact":1,"gen_end":35367,"gen_start":34957,"node":120,"role":"declaration","source":0,"src_end":22662,"src_start":22473},{"artifact":1,"gen_end":35756,"gen_start":35367,"node":121,"role":"declaration","source":0,"src_end":22849,"src_start":22664},{"artifact":1,"gen_end":36498,"gen_start":35756,"node":122,"role":"declaration","source":0,"src_end":23425,"src_start":22851},{"artifact":1,"gen_end":37042,"gen_start":36498,"node":123,"role":"declaration","source":0,"src_end":23793,"src_start":23427},{"artifact":1,"gen_end":38049,"gen_start":37042,"node":124,"role":"declaration","source":0,"src_end":24592,"src_start":23795},{"artifact":1,"gen_end":39342,"gen_start":38049,"node":125,"role":"declaration","source":0,"src_end":25727,"src_start":24594},{"artifact":1,"gen_end":40723,"gen_start":39342,"node":126,"role":"declaration","source":0,"src_end":26835,"src_start":25729},{"artifact":1,"gen_end":41561,"gen_start":40723,"node":127,"role":"declaration","source":0,"src_end":27301,"src_start":26837},{"artifact":1,"gen_end":41576,"gen_start":41561,"node":64,"role":"declaration","source":0,"src_end":27337,"src_start":0}],"module":"AxiomOutput","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-declaration"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"},{"id":38,"kind":"semantic-declaration"},{"id":39,"kind":"semantic-declaration"},{"id":40,"kind":"semantic-declaration"},{"id":41,"kind":"semantic-declaration"},{"id":42,"kind":"semantic-declaration"},{"id":43,"kind":"semantic-declaration"},{"id":44,"kind":"semantic-declaration"},{"id":45,"kind":"semantic-declaration"},{"id":46,"kind":"semantic-declaration"},{"id":47,"kind":"semantic-declaration"},{"id":48,"kind":"semantic-declaration"},{"id":49,"kind":"semantic-declaration"},{"id":50,"kind":"semantic-declaration"},{"id":51,"kind":"semantic-declaration"},{"id":52,"kind":"semantic-declaration"},{"id":53,"kind":"semantic-declaration"},{"id":54,"kind":"semantic-declaration"},{"id":55,"kind":"semantic-declaration"},{"id":56,"kind":"semantic-declaration"},{"id":57,"kind":"semantic-declaration"},{"id":58,"kind":"semantic-declaration"},{"id":59,"kind":"semantic-declaration"},{"id":60,"kind":"semantic-declaration"},{"id":61,"kind":"semantic-declaration"},{"id":62,"kind":"semantic-declaration"},{"id":63,"kind":"semantic-declaration"},{"id":64,"kind":"semantic-latex-module"},{"id":65,"kind":"semantic-declaration"},{"id":66,"kind":"semantic-declaration"},{"id":67,"kind":"semantic-declaration"},{"id":68,"kind":"semantic-declaration"},{"id":69,"kind":"semantic-declaration"},{"id":70,"kind":"semantic-declaration"},{"id":71,"kind":"semantic-declaration"},{"id":72,"kind":"semantic-declaration"},{"id":73,"kind":"semantic-declaration"},{"id":74,"kind":"semantic-declaration"},{"id":75,"kind":"semantic-declaration"},{"id":76,"kind":"semantic-declaration"},{"id":77,"kind":"semantic-declaration"},{"id":78,"kind":"semantic-declaration"},{"id":79,"kind":"semantic-declaration"},{"id":80,"kind":"semantic-declaration"},{"id":81,"kind":"semantic-declaration"},{"id":82,"kind":"semantic-declaration"},{"id":83,"kind":"semantic-declaration"},{"id":84,"kind":"semantic-declaration"},{"id":85,"kind":"semantic-declaration"},{"id":86,"kind":"semantic-declaration"},{"id":87,"kind":"semantic-declaration"},{"id":88,"kind":"semantic-declaration"},{"id":89,"kind":"semantic-declaration"},{"id":90,"kind":"semantic-declaration"},{"id":91,"kind":"semantic-declaration"},{"id":92,"kind":"semantic-declaration"},{"id":93,"kind":"semantic-declaration"},{"id":94,"kind":"semantic-declaration"},{"id":95,"kind":"semantic-declaration"},{"id":96,"kind":"semantic-declaration"},{"id":97,"kind":"semantic-declaration"},{"id":98,"kind":"semantic-declaration"},{"id":99,"kind":"semantic-declaration"},{"id":100,"kind":"semantic-declaration"},{"id":101,"kind":"semantic-declaration"},{"id":102,"kind":"semantic-declaration"},{"id":103,"kind":"semantic-declaration"},{"id":104,"kind":"semantic-declaration"},{"id":105,"kind":"semantic-declaration"},{"id":106,"kind":"semantic-declaration"},{"id":107,"kind":"semantic-declaration"},{"id":108,"kind":"semantic-declaration"},{"id":109,"kind":"semantic-declaration"},{"id":110,"kind":"semantic-declaration"},{"id":111,"kind":"semantic-declaration"},{"id":112,"kind":"semantic-declaration"},{"id":113,"kind":"semantic-declaration"},{"id":114,"kind":"semantic-declaration"},{"id":115,"kind":"semantic-declaration"},{"id":116,"kind":"semantic-declaration"},{"id":117,"kind":"semantic-declaration"},{"id":118,"kind":"semantic-declaration"},{"id":119,"kind":"semantic-declaration"},{"id":120,"kind":"semantic-declaration"},{"id":121,"kind":"semantic-declaration"},{"id":122,"kind":"semantic-declaration"},{"id":123,"kind":"semantic-declaration"},{"id":124,"kind":"semantic-declaration"},{"id":125,"kind":"semantic-declaration"},{"id":126,"kind":"semantic-declaration"},{"id":127,"kind":"semantic-declaration"}],"semantic_id":"5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48","source_id":"d24d87e6939b30919be5d863ae8caee196592ffc1481d8490690c0f435e12acf","sources":[{"id":0,"kind":"file","path":"src/AxiomOutput.lex.tex","sha256":"9f046a50790b9f317a465924703c96839422f20e631a6f6162cc6514955e8567"}],"spec":"lexlean/source-map/1"} diff --git a/bootstrap/expected/build/maps/LexLeanBoot/Text.map.json b/bootstrap/expected/build/maps/LexLeanBoot/Text.map.json index 229222331..13f6116e3 100644 --- a/bootstrap/expected/build/maps/LexLeanBoot/Text.map.json +++ b/bootstrap/expected/build/maps/LexLeanBoot/Text.map.json @@ -1 +1 @@ -{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanBoot/Text.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanBoot/Text.tex"}],"mappings":[{"artifact":0,"gen_end":278,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":0,"gen_end":612,"gen_start":278,"node":1,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":0,"gen_end":761,"gen_start":612,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":0,"gen_end":941,"gen_start":761,"node":3,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":0,"gen_end":1182,"gen_start":941,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":0,"gen_end":1483,"gen_start":1182,"node":5,"role":"declaration","source":0,"src_end":1373,"src_start":1087},{"artifact":0,"gen_end":1949,"gen_start":1483,"node":6,"role":"declaration","source":0,"src_end":1804,"src_start":1375},{"artifact":0,"gen_end":2385,"gen_start":1949,"node":7,"role":"declaration","source":0,"src_end":2233,"src_start":1806},{"artifact":0,"gen_end":2697,"gen_start":2385,"node":8,"role":"declaration","source":0,"src_end":2598,"src_start":2235},{"artifact":0,"gen_end":2933,"gen_start":2697,"node":9,"role":"declaration","source":0,"src_end":2845,"src_start":2600},{"artifact":0,"gen_end":3178,"gen_start":2933,"node":10,"role":"declaration","source":0,"src_end":3092,"src_start":2847},{"artifact":0,"gen_end":3836,"gen_start":3178,"node":11,"role":"declaration","source":0,"src_end":3859,"src_start":3094},{"artifact":0,"gen_end":4453,"gen_start":3836,"node":12,"role":"declaration","source":0,"src_end":4438,"src_start":3861},{"artifact":0,"gen_end":4668,"gen_start":4453,"node":13,"role":"declaration","source":0,"src_end":4650,"src_start":4440},{"artifact":0,"gen_end":5316,"gen_start":4668,"node":14,"role":"declaration","source":0,"src_end":5408,"src_start":4652},{"artifact":0,"gen_end":5999,"gen_start":5316,"node":15,"role":"declaration","source":0,"src_end":6032,"src_start":5410},{"artifact":0,"gen_end":6506,"gen_start":5999,"node":16,"role":"declaration","source":0,"src_end":6559,"src_start":6034},{"artifact":0,"gen_end":6820,"gen_start":6506,"node":17,"role":"declaration","source":0,"src_end":6871,"src_start":6561},{"artifact":0,"gen_end":7408,"gen_start":6820,"node":18,"role":"declaration","source":0,"src_end":7530,"src_start":6873},{"artifact":0,"gen_end":7430,"gen_start":7408,"node":0,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":19,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":1,"gen_end":715,"gen_start":134,"node":20,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":1,"gen_end":1111,"gen_start":715,"node":21,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":1,"gen_end":1538,"gen_start":1111,"node":22,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":1,"gen_end":2027,"gen_start":1538,"node":23,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":1,"gen_end":2611,"gen_start":2027,"node":24,"role":"declaration","source":0,"src_end":1373,"src_start":1087},{"artifact":1,"gen_end":3324,"gen_start":2611,"node":25,"role":"declaration","source":0,"src_end":1804,"src_start":1375},{"artifact":1,"gen_end":4131,"gen_start":3324,"node":26,"role":"declaration","source":0,"src_end":2233,"src_start":1806},{"artifact":1,"gen_end":4809,"gen_start":4131,"node":27,"role":"declaration","source":0,"src_end":2598,"src_start":2235},{"artifact":1,"gen_end":5328,"gen_start":4809,"node":28,"role":"declaration","source":0,"src_end":2845,"src_start":2600},{"artifact":1,"gen_end":5901,"gen_start":5328,"node":29,"role":"declaration","source":0,"src_end":3092,"src_start":2847},{"artifact":1,"gen_end":6806,"gen_start":5901,"node":30,"role":"declaration","source":0,"src_end":3859,"src_start":3094},{"artifact":1,"gen_end":7759,"gen_start":6806,"node":31,"role":"declaration","source":0,"src_end":4438,"src_start":3861},{"artifact":1,"gen_end":8222,"gen_start":7759,"node":32,"role":"declaration","source":0,"src_end":4650,"src_start":4440},{"artifact":1,"gen_end":9117,"gen_start":8222,"node":33,"role":"declaration","source":0,"src_end":5408,"src_start":4652},{"artifact":1,"gen_end":10125,"gen_start":9117,"node":34,"role":"declaration","source":0,"src_end":6032,"src_start":5410},{"artifact":1,"gen_end":10968,"gen_start":10125,"node":35,"role":"declaration","source":0,"src_end":6559,"src_start":6034},{"artifact":1,"gen_end":11529,"gen_start":10968,"node":36,"role":"declaration","source":0,"src_end":6871,"src_start":6561},{"artifact":1,"gen_end":12466,"gen_start":11529,"node":37,"role":"declaration","source":0,"src_end":7530,"src_start":6873},{"artifact":1,"gen_end":12481,"gen_start":12466,"node":19,"role":"declaration","source":0,"src_end":7566,"src_start":0}],"module":"Text","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-latex-module"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"}],"semantic_id":"adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb","source_id":"3f41dc0286cbb4e5618c5f0a330c60e2e4f7245869b4343f0b3859285a3d4f7e","sources":[{"id":0,"kind":"file","path":"src/Text.lex.tex","sha256":"2c97a6b06a1c39aa660edc43f366b753175279f9dc99bbea9bb7f900eb1b9a07"}],"spec":"lexlean/source-map/1"} +{"artifacts":[{"id":0,"kind":"lean","path":"modules/LexLeanBoot/Text.lean"},{"id":1,"kind":"tex","path":"modules/LexLeanBoot/Text.tex"}],"mappings":[{"artifact":0,"gen_end":278,"gen_start":0,"node":0,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":0,"gen_end":612,"gen_start":278,"node":1,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":0,"gen_end":761,"gen_start":612,"node":2,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":0,"gen_end":941,"gen_start":761,"node":3,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":0,"gen_end":1182,"gen_start":941,"node":4,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":0,"gen_end":1483,"gen_start":1182,"node":5,"role":"declaration","source":0,"src_end":1373,"src_start":1087},{"artifact":0,"gen_end":1949,"gen_start":1483,"node":6,"role":"declaration","source":0,"src_end":1804,"src_start":1375},{"artifact":0,"gen_end":2385,"gen_start":1949,"node":7,"role":"declaration","source":0,"src_end":2233,"src_start":1806},{"artifact":0,"gen_end":2697,"gen_start":2385,"node":8,"role":"declaration","source":0,"src_end":2598,"src_start":2235},{"artifact":0,"gen_end":2933,"gen_start":2697,"node":9,"role":"declaration","source":0,"src_end":2845,"src_start":2600},{"artifact":0,"gen_end":3178,"gen_start":2933,"node":10,"role":"declaration","source":0,"src_end":3092,"src_start":2847},{"artifact":0,"gen_end":3836,"gen_start":3178,"node":11,"role":"declaration","source":0,"src_end":3859,"src_start":3094},{"artifact":0,"gen_end":4453,"gen_start":3836,"node":12,"role":"declaration","source":0,"src_end":4438,"src_start":3861},{"artifact":0,"gen_end":4668,"gen_start":4453,"node":13,"role":"declaration","source":0,"src_end":4650,"src_start":4440},{"artifact":0,"gen_end":5316,"gen_start":4668,"node":14,"role":"declaration","source":0,"src_end":5408,"src_start":4652},{"artifact":0,"gen_end":5999,"gen_start":5316,"node":15,"role":"declaration","source":0,"src_end":6032,"src_start":5410},{"artifact":0,"gen_end":6506,"gen_start":5999,"node":16,"role":"declaration","source":0,"src_end":6559,"src_start":6034},{"artifact":0,"gen_end":6820,"gen_start":6506,"node":17,"role":"declaration","source":0,"src_end":6871,"src_start":6561},{"artifact":0,"gen_end":7408,"gen_start":6820,"node":18,"role":"declaration","source":0,"src_end":7530,"src_start":6873},{"artifact":0,"gen_end":7430,"gen_start":7408,"node":0,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":1,"gen_end":134,"gen_start":0,"node":19,"role":"declaration","source":0,"src_end":7566,"src_start":0},{"artifact":1,"gen_end":715,"gen_start":134,"node":20,"role":"declaration","source":0,"src_end":426,"src_start":113},{"artifact":1,"gen_end":1111,"gen_start":715,"node":21,"role":"declaration","source":0,"src_end":607,"src_start":428},{"artifact":1,"gen_end":1538,"gen_start":1111,"node":22,"role":"declaration","source":0,"src_end":834,"src_start":609},{"artifact":1,"gen_end":2027,"gen_start":1538,"node":23,"role":"declaration","source":0,"src_end":1085,"src_start":836},{"artifact":1,"gen_end":2611,"gen_start":2027,"node":24,"role":"declaration","source":0,"src_end":1373,"src_start":1087},{"artifact":1,"gen_end":3324,"gen_start":2611,"node":25,"role":"declaration","source":0,"src_end":1804,"src_start":1375},{"artifact":1,"gen_end":4131,"gen_start":3324,"node":26,"role":"declaration","source":0,"src_end":2233,"src_start":1806},{"artifact":1,"gen_end":4809,"gen_start":4131,"node":27,"role":"declaration","source":0,"src_end":2598,"src_start":2235},{"artifact":1,"gen_end":5328,"gen_start":4809,"node":28,"role":"declaration","source":0,"src_end":2845,"src_start":2600},{"artifact":1,"gen_end":5901,"gen_start":5328,"node":29,"role":"declaration","source":0,"src_end":3092,"src_start":2847},{"artifact":1,"gen_end":6806,"gen_start":5901,"node":30,"role":"declaration","source":0,"src_end":3859,"src_start":3094},{"artifact":1,"gen_end":7759,"gen_start":6806,"node":31,"role":"declaration","source":0,"src_end":4438,"src_start":3861},{"artifact":1,"gen_end":8222,"gen_start":7759,"node":32,"role":"declaration","source":0,"src_end":4650,"src_start":4440},{"artifact":1,"gen_end":9117,"gen_start":8222,"node":33,"role":"declaration","source":0,"src_end":5408,"src_start":4652},{"artifact":1,"gen_end":10125,"gen_start":9117,"node":34,"role":"declaration","source":0,"src_end":6032,"src_start":5410},{"artifact":1,"gen_end":10968,"gen_start":10125,"node":35,"role":"declaration","source":0,"src_end":6559,"src_start":6034},{"artifact":1,"gen_end":11529,"gen_start":10968,"node":36,"role":"declaration","source":0,"src_end":6871,"src_start":6561},{"artifact":1,"gen_end":12466,"gen_start":11529,"node":37,"role":"declaration","source":0,"src_end":7530,"src_start":6873},{"artifact":1,"gen_end":12481,"gen_start":12466,"node":19,"role":"declaration","source":0,"src_end":7566,"src_start":0}],"module":"Text","nodes":[{"id":0,"kind":"semantic-lean-module"},{"id":1,"kind":"semantic-declaration"},{"id":2,"kind":"semantic-declaration"},{"id":3,"kind":"semantic-declaration"},{"id":4,"kind":"semantic-declaration"},{"id":5,"kind":"semantic-declaration"},{"id":6,"kind":"semantic-declaration"},{"id":7,"kind":"semantic-declaration"},{"id":8,"kind":"semantic-declaration"},{"id":9,"kind":"semantic-declaration"},{"id":10,"kind":"semantic-declaration"},{"id":11,"kind":"semantic-declaration"},{"id":12,"kind":"semantic-declaration"},{"id":13,"kind":"semantic-declaration"},{"id":14,"kind":"semantic-declaration"},{"id":15,"kind":"semantic-declaration"},{"id":16,"kind":"semantic-declaration"},{"id":17,"kind":"semantic-declaration"},{"id":18,"kind":"semantic-declaration"},{"id":19,"kind":"semantic-latex-module"},{"id":20,"kind":"semantic-declaration"},{"id":21,"kind":"semantic-declaration"},{"id":22,"kind":"semantic-declaration"},{"id":23,"kind":"semantic-declaration"},{"id":24,"kind":"semantic-declaration"},{"id":25,"kind":"semantic-declaration"},{"id":26,"kind":"semantic-declaration"},{"id":27,"kind":"semantic-declaration"},{"id":28,"kind":"semantic-declaration"},{"id":29,"kind":"semantic-declaration"},{"id":30,"kind":"semantic-declaration"},{"id":31,"kind":"semantic-declaration"},{"id":32,"kind":"semantic-declaration"},{"id":33,"kind":"semantic-declaration"},{"id":34,"kind":"semantic-declaration"},{"id":35,"kind":"semantic-declaration"},{"id":36,"kind":"semantic-declaration"},{"id":37,"kind":"semantic-declaration"}],"semantic_id":"5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48","source_id":"d24d87e6939b30919be5d863ae8caee196592ffc1481d8490690c0f435e12acf","sources":[{"id":0,"kind":"file","path":"src/Text.lex.tex","sha256":"2c97a6b06a1c39aa660edc43f366b753175279f9dc99bbea9bb7f900eb1b9a07"}],"spec":"lexlean/source-map/1"} diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.lean b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.lean similarity index 100% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.lean rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.lean diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.process.json b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.process.json similarity index 96% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.process.json rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.process.json index 761403b59..e7ed934d0 100644 --- a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.process.json +++ b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.AxiomOutput","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanBoot.AxiomOutput.Record' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.Rejection' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.Scan' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.afterLabel' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.afterLocation' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.allDigits' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.auditStep' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.axiomList' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.byteIn' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.byteIs' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.cat' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.collectStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.continuation' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.decimal' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.digit' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.digitStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.dropWhiteEnd' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.envelope' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.extend' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.finish' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.fitsWord' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.headOf' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.inRange' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.insertAxiom' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.insertEntry' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.isClosedLeanName' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isCount' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isFirst' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isLater' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isWord' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.lastStep' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.lessBytes' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.listLength' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.listed' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.located' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.malformed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.nameMode' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.nameStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.notLean' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.parseAuditOutput' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.parsePayload' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.parsed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.quoted' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.refuse' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.rejected' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.reversed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.scanStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.significant' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.skipWhite' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.splitLast' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.splitOnce' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.startsWhite' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.stop' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.stripPrefix' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.stripSuffix' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.tailOf' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.terminates' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.text' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.trimmed' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.unrecognized' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.whiteEnding' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.whiteLength' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.zeroStep' does not depend on any axioms\n","stdout_sha256":"bd365d474943e5184f5b9e376d67d1c8fca4b097fa1da5b05bae624f013e1d09","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.AxiomOutput","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanBoot.AxiomOutput.Record' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.Rejection' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.Scan' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.afterLabel' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.afterLocation' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.allDigits' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.auditStep' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.axiomList' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.byteIn' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.byteIs' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.cat' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.collectStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.continuation' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.decimal' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.digit' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.digitStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.dropWhiteEnd' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.envelope' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.extend' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.finish' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.fitsWord' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.headOf' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.inRange' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.insertAxiom' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.insertEntry' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.isClosedLeanName' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isCount' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isFirst' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isLater' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.isWord' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.lastStep' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.lessBytes' depends on axioms: [propext]\n'LexLeanBoot.AxiomOutput.listLength' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.listed' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.located' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.malformed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.nameMode' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.nameStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.notLean' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.parseAuditOutput' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.parsePayload' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.parsed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.quoted' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.refuse' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.rejected' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.reversed' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.scanStep' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.significant' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.skipWhite' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.splitLast' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.splitOnce' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.startsWhite' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.stop' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.stripPrefix' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.stripSuffix' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.tailOf' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.terminates' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.text' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.trimmed' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.unrecognized' does not depend on any axioms\n'LexLeanBoot.AxiomOutput.whiteEnding' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.whiteLength' depends on axioms: [propext, Quot.sound]\n'LexLeanBoot.AxiomOutput.zeroStep' does not depend on any axioms\n","stdout_sha256":"bd365d474943e5184f5b9e376d67d1c8fca4b097fa1da5b05bae624f013e1d09","tool":"lean"} diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.lean b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.lean similarity index 100% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.lean rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.lean diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.process.json b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.process.json similarity index 82% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.process.json rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.process.json index 1498f857d..e8b12ed3d 100644 --- a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.process.json +++ b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanBoot.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanBoot.Text.byteAt' does not depend on any axioms\n'LexLeanBoot.Text.chomp' does not depend on any axioms\n'LexLeanBoot.Text.endsWith' does not depend on any axioms\n'LexLeanBoot.Text.find' does not depend on any axioms\n'LexLeanBoot.Text.isSpace' does not depend on any axioms\n'LexLeanBoot.Text.joinWith' does not depend on any axioms\n'LexLeanBoot.Text.lineStep' does not depend on any axioms\n'LexLeanBoot.Text.lines' does not depend on any axioms\n'LexLeanBoot.Text.matchAt' does not depend on any axioms\n'LexLeanBoot.Text.reverse' does not depend on any axioms\n'LexLeanBoot.Text.sliceOr' does not depend on any axioms\n'LexLeanBoot.Text.spaceAt' does not depend on any axioms\n'LexLeanBoot.Text.splitOn' does not depend on any axioms\n'LexLeanBoot.Text.splitStep' does not depend on any axioms\n'LexLeanBoot.Text.startsWith' does not depend on any axioms\n'LexLeanBoot.Text.trim' does not depend on any axioms\n'LexLeanBoot.Text.trimEnd' does not depend on any axioms\n'LexLeanBoot.Text.trimStart' does not depend on any axioms\n","stdout_sha256":"f123b29dcd243a53b7c289ef056e99264e1132f910ec78803c53edf0c6543bc0","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanBoot.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanBoot.Text.byteAt' does not depend on any axioms\n'LexLeanBoot.Text.chomp' does not depend on any axioms\n'LexLeanBoot.Text.endsWith' does not depend on any axioms\n'LexLeanBoot.Text.find' does not depend on any axioms\n'LexLeanBoot.Text.isSpace' does not depend on any axioms\n'LexLeanBoot.Text.joinWith' does not depend on any axioms\n'LexLeanBoot.Text.lineStep' does not depend on any axioms\n'LexLeanBoot.Text.lines' does not depend on any axioms\n'LexLeanBoot.Text.matchAt' does not depend on any axioms\n'LexLeanBoot.Text.reverse' does not depend on any axioms\n'LexLeanBoot.Text.sliceOr' does not depend on any axioms\n'LexLeanBoot.Text.spaceAt' does not depend on any axioms\n'LexLeanBoot.Text.splitOn' does not depend on any axioms\n'LexLeanBoot.Text.splitStep' does not depend on any axioms\n'LexLeanBoot.Text.startsWith' does not depend on any axioms\n'LexLeanBoot.Text.trim' does not depend on any axioms\n'LexLeanBoot.Text.trimEnd' does not depend on any axioms\n'LexLeanBoot.Text.trimStart' does not depend on any axioms\n","stdout_sha256":"f123b29dcd243a53b7c289ef056e99264e1132f910ec78803c53edf0c6543bc0","tool":"lean"} diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.lean b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.lean similarity index 100% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.lean rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.process.json b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.process.json similarity index 97% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.process.json rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.process.json index fcf0cf722..f99ad750c 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.process.json +++ b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.lean b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.lean similarity index 100% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.lean rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.lean diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.process.json b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.process.json similarity index 98% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.process.json rename to bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.process.json index a28833831..ae4ac903d 100644 --- a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.process.json +++ b/bootstrap/expected/verify/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5ba510b7049a3e59c5f1ffb1f0a6611d.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/bootstrap/expected/verify/extract/LexLeanExtract.Xadb40bbfc73b1dc6b7a95dab0c348a27.lean b/bootstrap/expected/verify/extract/LexLeanExtract.X5ba510b7049a3e59c5f1ffb1f0a6611d.lean similarity index 100% rename from bootstrap/expected/verify/extract/LexLeanExtract.Xadb40bbfc73b1dc6b7a95dab0c348a27.lean rename to bootstrap/expected/verify/extract/LexLeanExtract.X5ba510b7049a3e59c5f1ffb1f0a6611d.lean diff --git a/bootstrap/expected/verify/extract/process.json b/bootstrap/expected/verify/extract/process.json index 7c32e86e8..fc48bdec0 100644 --- a/bootstrap/expected/verify/extract/process.json +++ b/bootstrap/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xadb40bbfc73b1dc6b7a95dab0c348a27.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xadb40bbfc73b1dc6b7a95dab0c348a27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.parseAuditOutput\"],\"constants\":[{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHSub\",\"HSub.hSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}}}}}}}},\"uses\":[\"HSub\",\"Int\",\"Option\",\"Sub\",\"instHSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.compareBytes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"Ord.compare\",\"UInt8.instOrd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOrd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.instOrd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Ord\",\"Ordering\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"UInt8.instOrd\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"UInt8\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt8.complement\",\"UInt8.land\",\"UInt8.lor\",\"UInt8.ofInt\",\"UInt8.ofNat\",\"UInt8.shiftLeft\",\"UInt8.shiftRight\",\"UInt8.toNat\",\"UInt8.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"255\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"UInt8\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt8.complement\",\"UInt8.land\",\"UInt8.lor\",\"UInt8.ofInt\",\"UInt8.ofNat\",\"UInt8.shiftLeft\",\"UInt8.shiftRight\",\"UInt8.toNat\",\"UInt8.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"BEq.beq\",\"Nat.div\",\"Nat.mod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.div\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.mod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"Nat.div\",\"Nat.mod\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.remainder\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":1,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Encode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.toUTF8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.toUTF8\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"String.toUTF8\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}}}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":0,\"fields\":4,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.none\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"info: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}]}}}}}}}}},\"uses\":[\"ByteArray\",\"Option\",\"PUnit\",\"String\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.afterLocation\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.afterLabel\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.146\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.126\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.141\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}]}}}}]}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.164\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.193\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.188\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.177\"}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.193\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"-\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.204\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.194\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.205\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.206\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.afterLabel\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.allDigits\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.digitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"LexLeanBoot.AxiomOutput.digitStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.auditStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"Except.ok\",\"LexLeanRuntime.equal\",\"List.nil\",\"List.toArray\",\"Option.some\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.Record.axioms\",\"LexLeanBoot.AxiomOutput.Record.declaration\",\"LexLeanBoot.AxiomOutput.Record.expected\",\"LexLeanBoot.AxiomOutput.auditStep.match_1\",\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.190\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":2,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.183\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"duplicate record for \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"expected a record for \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\", found \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.152\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.154\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.160\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.166\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":1,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.176\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.180\"}}}]}}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.186\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.189\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.116\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.186\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.189\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.191\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"UInt8\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanRuntime.equal\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.axiomList\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"UInt8\",\"Unit\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.collectStep\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.splitOn\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\",\"LexLeanBoot.AxiomOutput.collectStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"an axiom list cannot be empty\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.collectStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.splitOn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}]}}}}}}}}}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"String\",\"UInt8\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.collectStep\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.splitOn\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"LexLeanRuntime.equal\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"LexLeanRuntime.equal\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.collectStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.collectStep.match_1\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"duplicate axiom name \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}]}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.51\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.continuation\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.startsWhite\",\"LexLeanBoot.AxiomOutput.trimmed\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.startsWhite\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}}}}}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.startsWhite\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"Nat.beq\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.digit\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.59\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.71\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.136\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"Nat.beq\",\"LexLeanBoot.AxiomOutput.digit\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"0123456789\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}}}}}}}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"OfNat\",\"String\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.digitStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}}}}}]}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.whiteEnding\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteEnding\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.whiteEnding\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.envelope\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.some\",\"LexLeanBoot.AxiomOutput.located\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.startsWith\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"'\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.startsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.located\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"info: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.located\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.startsWith\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"List.cons\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.parsePayload\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.tailOf\",\"LexLeanBoot.AxiomOutput.terminates\",\"LexLeanBoot.AxiomOutput.Record.mk\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.extend.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.terminates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.50\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.tailOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsePayload\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}]}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.cons\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.parsePayload\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.tailOf\",\"LexLeanBoot.AxiomOutput.terminates\",\"LexLeanBoot.AxiomOutput.Record.mk\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.finish\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"Nat.beq\",\"Option.none\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.auditStep\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.decimal\",\"LexLeanBoot.AxiomOutput.listLength\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.reversed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.scanStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unterminated axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"expected \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" audit records, found \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.135\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.143\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.auditStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.reversed\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}}}}}}]}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.155\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"LexLeanBoot.AxiomOutput.Scan\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.156\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.171\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"Nat.beq\",\"Option.none\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.auditStep\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.decimal\",\"LexLeanBoot.AxiomOutput.listLength\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.reversed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.fitsWord\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqOrdering\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.28\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.39\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"18446744073709551615\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}}}}}}}}}}}}}}}}}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Ordering\",\"String\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqOrdering\",\"instOfNatNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Nat.beq\",\"Nat.blt\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Unit\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Option\",\"PUnit\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedUInt8\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.82\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.103\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedUInt8\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"List.brecOn\",\"LexLeanBoot.AxiomOutput.insertAxiom._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.148\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.108\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.146\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.158\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}]}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.lessBytes\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"List.brecOn\",\"LexLeanBoot.AxiomOutput.insertEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.175\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.160\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.173\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.175\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.78\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}]}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.lessBytes\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.nameStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.nameStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.nameStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.isWord\",\"LexLeanBoot.AxiomOutput.trimmed\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isWord\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Bool\",\"ByteArray\",\"LexLeanBoot.AxiomOutput.isWord\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"65\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"97\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"122\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"95\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}]}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isLater\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.AxiomOutput.isFirst\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"39\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.AxiomOutput.isFirst\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isWord\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.allDigits\",\"LexLeanBoot.AxiomOutput.fitsWord\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"+\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.fitsWord\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.84\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.allDigits\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}]}}}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.allDigits\",\"LexLeanBoot.AxiomOutput.fitsWord\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.lastStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.26\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.listFold\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.listed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.axiomList\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.splitLast\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.axiomList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.76\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"' depends on axioms: [\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitLast\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.axiomList\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.splitLast\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.located\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.afterLocation\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.135\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLocation\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.105\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.129\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.140\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.152\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.156\"}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.158\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.174\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.164\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.afterLocation\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"Except.error\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.error\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.nameMode\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"Nat.beq\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.isFirst\",\"LexLeanBoot.AxiomOutput.isLater\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isLater\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}]}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}}}]}}}}}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"Nat.beq\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.isFirst\",\"LexLeanBoot.AxiomOutput.isLater\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.nameStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"Nat.beq\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.nameMode\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.nameMode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}]}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.nameMode\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" is not a Lean name\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parseAuditOutput\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.nil\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.finish\",\"LexLeanBoot.AxiomOutput.scanStep\",\"LexLeanBoot.Text.lines\",\"LexLeanBoot.AxiomOutput.Scan.between\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.20\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.scanStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.lines\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.finish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.finish\",\"LexLeanBoot.AxiomOutput.scanStep\",\"LexLeanBoot.Text.lines\",\"LexLeanBoot.AxiomOutput.Scan.between\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsePayload\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"List.nil\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.listed\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\",\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"LexLeanBoot.AxiomOutput.parsePayload.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.150\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.102\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.133\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.114\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"]\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.127\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.133\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"' does not depend on any axioms\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.146\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"'\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.161\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.listed\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"Except.ok\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.ok\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"`\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"Except.error\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.rejected\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Option\",\"Prod\",\"Except.error\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.rejected\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Rejection.mk\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.reversed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.20\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}},\"uses\":[\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.scanStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.continuation\",\"LexLeanBoot.AxiomOutput.envelope\",\"LexLeanBoot.AxiomOutput.extend\",\"LexLeanBoot.AxiomOutput.headOf\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"LexLeanBoot.AxiomOutput.scanStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.127\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.136\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unterminated axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.continuation\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.145\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.209\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.168\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.183\",\"parameters\":[{\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.183\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.192\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unrecognized audit line: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.191\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.envelope\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.193\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.184\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.207\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"LexLeanBoot.AxiomOutput.Scan\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.223\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.225\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":[{\"id\":\"_uniq.226\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.226\"},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"},{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.230\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":[{\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.232\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.continuation\",\"LexLeanBoot.AxiomOutput.envelope\",\"LexLeanBoot.AxiomOutput.extend\",\"LexLeanBoot.AxiomOutput.headOf\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.zeroStep\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.zeroStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.zeroStep\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.skipWhite\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitLast\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lastStep\",\"LexLeanBoot.Text.matchAt\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lastStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}}}}}}}]}}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}]}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lastStep\",\"LexLeanBoot.Text.matchAt\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanBoot.Text.find\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.AxiomOutput.splitOnce.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.find\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}}}},\"uses\":[\"Add\",\"ByteArray\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.Text.find\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.startsWhite\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.rejected\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.rejected\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.startsWith\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.startsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.startsWith\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.tailOf\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Unit\",\"List.nil\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}}},\"uses\":[\"ByteArray\",\"List\",\"PUnit\",\"List.cons\",\"List.nil\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.terminates\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Option\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" does not depend on any axioms\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"]\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.90\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Option\",\"PUnit\",\"String\",\"Bool.false\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.text\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanRuntime.utf8Encode\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanRuntime.utf8Encode\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"LexLeanBoot.AxiomOutput.skipWhite\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.skipWhite\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"LexLeanBoot.AxiomOutput.skipWhite\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unrecognized axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.whiteEnding\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.131\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.91\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.121\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\",\"LexLeanBoot.AxiomOutput.byteIs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.102\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.105\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.556\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.130\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"194\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"225\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.155\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"226\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.169\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.172\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"227\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.183\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.186\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.189\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.209\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.212\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.215\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.216\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.252\",\"parameters\":[{\"id\":\"_uniq.241\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.241\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.242\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.243\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.246\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.247\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.248\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.250\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.219\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.220\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.222\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.234\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.235\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.236\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.237\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.238\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.238\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.239\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.264\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.263\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.265\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.264\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.267\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.268\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.271\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.273\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"},{\"kind\":\"fvar\",\"id\":\"_uniq.272\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.273\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.274\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"129\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.293\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.292\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.294\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.293\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.295\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"},{\"kind\":\"fvar\",\"id\":\"_uniq.294\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.295\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.332\",\"parameters\":[{\"id\":\"_uniq.321\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.322\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.321\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.322\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.323\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.324\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.325\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.324\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.326\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.325\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.326\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.327\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.328\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.329\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.328\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.330\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.329\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.330\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.296\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.297\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.298\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.299\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.310\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.309\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.310\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.312\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"159\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.312\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.313\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.315\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.311\"},{\"kind\":\"fvar\",\"id\":\"_uniq.314\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.316\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.315\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.316\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.317\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.318\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.318\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.319\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.333\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.350\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.351\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.350\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.352\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.351\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.353\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.352\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.354\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"138\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.355\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.354\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.356\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.355\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.357\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.272\"},{\"kind\":\"fvar\",\"id\":\"_uniq.356\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.358\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.357\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.421\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.411\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.411\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.414\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.414\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.415\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.416\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.417\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.417\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.418\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.358\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.359\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.368\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"168\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.369\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.368\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.370\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.369\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.371\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.370\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.372\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.371\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.372\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.373\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.382\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"169\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.382\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.384\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.383\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.385\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.384\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.386\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.385\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.386\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.387\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.396\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"175\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.397\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.396\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.398\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.397\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.398\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.400\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.401\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.402\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.402\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.403\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.405\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.409\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}}]}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.441\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.442\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.441\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.443\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.442\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.444\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.445\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.444\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.446\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.445\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.447\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.443\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.446\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.448\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"154\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.449\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.448\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.450\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.449\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.451\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.447\"},{\"kind\":\"fvar\",\"id\":\"_uniq.450\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.452\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.451\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.488\",\"parameters\":[{\"id\":\"_uniq.477\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.478\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.477\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.478\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.479\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.480\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.481\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.480\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.482\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.481\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.482\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.483\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.484\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.485\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.484\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.486\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.485\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.486\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.452\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.453\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.454\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.454\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.455\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.464\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.465\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.464\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.466\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.465\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.467\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.443\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.466\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.468\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.469\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.468\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.470\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.469\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.471\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.467\"},{\"kind\":\"fvar\",\"id\":\"_uniq.470\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.472\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.471\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.472\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.473\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.474\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.474\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.475\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.490\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.507\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.508\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.507\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.509\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.508\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.510\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.511\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.510\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.512\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.511\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.513\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.509\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.512\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.514\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"133\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.515\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.514\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.516\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.515\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.517\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.513\"},{\"kind\":\"fvar\",\"id\":\"_uniq.516\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.518\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.517\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.549\",\"parameters\":[{\"id\":\"_uniq.538\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.539\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.538\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.539\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.540\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.541\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.542\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.541\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.543\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.542\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.543\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.544\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.545\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.546\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.545\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.547\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.546\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.547\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.518\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.519\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.528\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"160\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.529\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.528\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.530\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.529\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.531\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.513\"},{\"kind\":\"fvar\",\"id\":\"_uniq.530\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.532\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.531\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.532\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.533\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.534\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.534\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.535\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.537\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.551\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.552\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.553\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.552\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.554\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.553\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.554\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\",\"LexLeanBoot.AxiomOutput.byteIs\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.zeroStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}]}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIs\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.byteAt\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"UInt8\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.chomp\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}]}}}}}}}}}}}},\"uses\":[\"Array\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Sub\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.endsWith\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}]}}}}}}}}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.find\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}]}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.lineStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.chomp\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.chomp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}}}}}}}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.122\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.chomp\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.lines\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.lineStep\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.lineStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Prod.mk\",\"LexLeanBoot.Text.lineStep\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.matchAt\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.reverse\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}},\"uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.sliceOr\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.splitOn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Prod\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.splitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.splitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.splitStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.splitStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}}}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.startsWith\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"OfNat.ofNat\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}]}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.axioms\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.declaration\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.expected\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.casesOn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.rec\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.rec\",\"kind\":\"recursor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.afterLocation.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.auditStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"LexLeanBoot.AxiomOutput.Rejection\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.axiomList.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.collectStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.extend.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.inRange.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom._f\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.lessBytes\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lessBytes\",\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"LexLeanBoot.AxiomOutput.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsePayload.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.scanStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.casesOn\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitOnce.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.Text.sliceOr.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.Text.spaceAt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"String\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqOrdering\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt8\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.div\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.mod\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"String.toUTF8\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.UInt\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"8936693ae9a91f38acfc70d3ebc0d4683efcc54907e455298d72339e1e36cead","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X5ba510b7049a3e59c5f1ffb1f0a6611d.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X5ba510b7049a3e59c5f1ffb1f0a6611d","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.parseAuditOutput\"],\"constants\":[{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Fixed\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Fixed.mk\",\"parameters\":1,\"fields\":10,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"bvar\",\"index\":2}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":4},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"bvar\",\"index\":6}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":5},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"bvar\",\"index\":7}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":6},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":7},\"codomain\":{\"kind\":\"bvar\",\"index\":8}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":8},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":9},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":11}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":10}]}}}}}}}}}}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Quotient\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Quotient.mk\",\"parameters\":1,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.ToMathInt\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedFromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Option\",\"ite\",\"Int.decLt\",\"Int.instLTInt\",\"LT.lt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Fixed.fromInt\",\"LexLeanRuntime.Fixed.maximum\",\"LexLeanRuntime.Fixed.minimum\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":2,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.33\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":3,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":1,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}]}}}},\"uses\":[\"Decidable\",\"Int\",\"Option\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.decLt\",\"LexLeanRuntime.Fixed\",\"Option.none\",\"Option.some\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.checkedSubtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"instHSub\",\"HSub.hSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedFromInt\",\"LexLeanRuntime.Fixed.toToMathInt\",\"LexLeanRuntime.ToMathInt.toInt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}},\"parameters\":[{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"borrow\":false},{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Int.instSub\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Fixed\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.ToMathInt\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedFromInt\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}}}}}}}},\"uses\":[\"HSub\",\"Int\",\"Option\",\"Sub\",\"instHSub\",\"Int.instSub\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"LexLeanRuntime.checkedFromInt\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.compareBytes\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"Ord.compare\",\"UInt8.instOrd\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOrd\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Ord\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.instOrd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"Ord\",\"index\":0,\"value\":\"_uniq.14\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.toList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Ord\",\"Ordering\",\"UInt8\",\"ByteArray.toList\",\"List.instOrd\",\"UInt8.instOrd\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instFixedUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Int\",\"Nat\",\"Option\",\"UInt32\",\"UInt8\",\"instLTNat\",\"instOfNat\",\"instOfNatNat\",\"ite\",\"Int.ofNat\",\"LT.lt\",\"Nat.decLt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt8.complement\",\"UInt8.land\",\"UInt8.lor\",\"UInt8.ofInt\",\"UInt8.ofNat\",\"UInt8.shiftLeft\",\"UInt8.shiftRight\",\"UInt8.toNat\",\"UInt8.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.16\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Int.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.15\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofInt\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"255\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Int\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.land\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.lor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.xor\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.complement\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.shiftLeft\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}}}]}}}}}}},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.78\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt32\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt32.toNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"8\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.ofNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.shiftRight\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.76\"}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}}}}}}},\"uses\":[\"Decidable\",\"Int\",\"Nat\",\"OfNat\",\"Option\",\"UInt32\",\"UInt8\",\"instOfNat\",\"instOfNatNat\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Int.ofNat\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.ToMathInt\",\"Nat.decLt\",\"Option.none\",\"Option.some\",\"UInt32.toNat\",\"UInt8.complement\",\"UInt8.land\",\"UInt8.lor\",\"UInt8.ofInt\",\"UInt8.ofNat\",\"UInt8.shiftLeft\",\"UInt8.shiftRight\",\"UInt8.toNat\",\"UInt8.xor\",\"LexLeanRuntime.Fixed.mk\",\"LexLeanRuntime.ToMathInt.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instQuotientNat\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"BEq.beq\",\"Nat.div\",\"Nat.mod\",\"OfNat.ofNat\",\"LexLeanRuntime.Quotient.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.div\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.3\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"Nat.mod\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.5\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.12\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.10\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.5\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.2\"},{\"kind\":\"fvar\",\"id\":\"_uniq.3\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"instBEqOfDecidableEq\",\"instDecidableEqNat\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"Nat.div\",\"Nat.mod\",\"LexLeanRuntime.Quotient.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.quotient\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.Quotient.isZero\",\"LexLeanRuntime.Quotient.remainder\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":3},\"codomain\":{\"kind\":\"bvar\",\"index\":4}}}}}},\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"borrow\":false},{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":2,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Quotient\",\"index\":1,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}]}}}}}},\"uses\":[\"Bool\",\"Decidable\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Quotient\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.utf8Encode\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"String.toUTF8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"String.toUTF8\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"String.toUTF8\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"parameters\":0,\"fields\":3,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}}}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"kind\":\"inductive\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":0,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":0,\"fields\":2,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":0,\"fields\":4,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}}},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":0,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}]}},{\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.none\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.34\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"info: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.41\",\"parameters\":[{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}]}}}}}}}}},\"uses\":[\"ByteArray\",\"Option\",\"PUnit\",\"String\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.afterLocation\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.afterLabel\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.170\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.146\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.93\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.126\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.127\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.141\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.142\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}]}}}}]}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.146\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.153\",\"parameters\":[{\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.152\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.153\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.164\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.166\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.154\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.165\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.166\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.147\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.168\"}}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.170\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.193\",\"parameters\":[{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLabel\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.188\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.189\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.177\"}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.194\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.193\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"-\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.203\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.204\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.206\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.194\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.205\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.206\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.207\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.171\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.207\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.208\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.afterLabel\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.allDigits\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.digitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"LexLeanBoot.AxiomOutput.digitStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.auditStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"Except.ok\",\"LexLeanRuntime.equal\",\"List.nil\",\"List.toArray\",\"Option.some\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.Record.axioms\",\"LexLeanBoot.AxiomOutput.Record.declaration\",\"LexLeanBoot.AxiomOutput.Record.expected\",\"LexLeanBoot.AxiomOutput.auditStep.match_1\",\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.77\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.77\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.190\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.95\",\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.95\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.104\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.103\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.104\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":2,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.183\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"duplicate record for \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":0,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"expected a record for \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\", found \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.138\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.139\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.152\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.153\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.140\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.154\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.160\",\"parameters\":[{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.159\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.160\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.166\",\"parameters\":[{\"id\":\"_uniq.165\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.166\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanBoot.AxiomOutput.Record\",\"index\":1,\"value\":\"_uniq.70\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.176\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.167\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.179\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.180\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.179\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.180\"}}}]}}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.186\",\"parameters\":[{\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.105\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.189\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.183\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.116\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.186\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.189\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.190\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.78\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.191\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"UInt8\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanRuntime.equal\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.axiomList\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"UInt8\",\"Unit\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.collectStep\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.splitOn\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\",\"LexLeanBoot.AxiomOutput.collectStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.107\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"an axiom list cannot be empty\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.91\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.124\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.collectStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.splitOn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.129\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.131\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}]}}}}}}}}}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Nat\",\"OfNat\",\"PUnit\",\"Prod\",\"String\",\"UInt8\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.collectStep\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.splitOn\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.60\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.73\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"LexLeanRuntime.equal\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.57\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"LexLeanRuntime.equal\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.collectStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.collectStep.match_1\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.82\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.89\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"duplicate axiom name \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.111\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.90\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}}]}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.51\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.60\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.continuation\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.startsWhite\",\"LexLeanBoot.AxiomOutput.trimmed\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.startsWhite\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}}}}}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.startsWhite\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"Nat.beq\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.digit\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.19\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.27\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.47\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.59\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.67\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.71\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.75\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.79\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1000\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"100\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.99\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.131\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.132\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.133\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.136\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.20\"}}]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"Nat.beq\",\"LexLeanBoot.AxiomOutput.digit\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.digit\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"0123456789\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Quotient\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instQuotientNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.17\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.quotient\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.remainder\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}}}}}}}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"OfNat\",\"String\",\"instOfNatNat\",\"LexLeanRuntime.Quotient\",\"LexLeanRuntime.instQuotientNat\",\"LexLeanRuntime.quotient\",\"LexLeanRuntime.remainder\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.digitStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.43\"}}}}}}}}}}]}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.whiteEnding\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.63\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteEnding\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.49\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.50\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.66\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.67\"}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.whiteEnding\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.envelope\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.some\",\"LexLeanBoot.AxiomOutput.located\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.startsWith\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"'\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.startsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.37\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.53\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.located\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.52\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"info: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.located\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.Text.startsWith\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"List.cons\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.parsePayload\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.tailOf\",\"LexLeanBoot.AxiomOutput.terminates\",\"LexLeanBoot.AxiomOutput.Record.mk\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.extend.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.terminates\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.50\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.51\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.tailOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsePayload\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Except\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.87\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Except.error\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}},{\"kind\":\"constructor\",\"constructor\":\"Except.ok\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}]}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"List.cons\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.parsePayload\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.tailOf\",\"LexLeanBoot.AxiomOutput.terminates\",\"LexLeanBoot.AxiomOutput.Record.mk\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.finish\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"Nat.beq\",\"Option.none\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.auditStep\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.decimal\",\"LexLeanBoot.AxiomOutput.listLength\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.reversed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.scanStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.81\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.80\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.100\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unterminated axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.100\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"expected \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" audit records, found \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.decimal\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.123\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.135\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.136\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.143\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"borrow\":false},{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.auditStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.142\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.144\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.reversed\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"},{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}}}}}}]}}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.155\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"LexLeanBoot.AxiomOutput.Scan\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.65\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":[{\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.156\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.171\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"},{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.82\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Nat\",\"Option\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Except.error\",\"Except.ok\",\"LexLeanCollections.listFold\",\"List.nil\",\"Nat.beq\",\"Option.none\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.auditStep\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.decimal\",\"LexLeanBoot.AxiomOutput.listLength\",\"LexLeanBoot.AxiomOutput.refuse\",\"LexLeanBoot.AxiomOutput.reversed\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.fitsWord\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqOrdering\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Nat.beq\",\"Nat.blt\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"20\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.28\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.39\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.40\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"18446744073709551615\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.not\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.64\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}}}}}}}}}}}}}}}}}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Ordering\",\"String\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqOrdering\",\"instOfNatNat\",\"Bool.false\",\"Bool.not\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"List.cons\",\"List.nil\",\"List.toArray\",\"Nat.beq\",\"Nat.blt\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Unit\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}}]}}}}}},\"uses\":[\"ByteArray\",\"List\",\"Option\",\"PUnit\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedUInt8\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.82\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Fixed\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instFixedUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.checkedSubtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.103\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.Fixed\",\"LexLeanRuntime.checkedSubtract\",\"LexLeanRuntime.instFixedUInt8\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"List.brecOn\",\"LexLeanBoot.AxiomOutput.insertAxiom._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.72\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.72\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.148\",\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.108\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.118\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.125\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.125\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.126\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.135\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.137\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.138\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.140\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.146\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.148\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.158\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.149\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.61\"},{\"kind\":\"fvar\",\"id\":\"_uniq.159\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.161\"}}}]}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Option\",\"PUnit\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.insertAxiom\",\"LexLeanBoot.AxiomOutput.lessBytes\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"List.brecOn\",\"LexLeanBoot.AxiomOutput.insertEntry._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.93\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.175\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.109\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.121\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.120\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.134\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.144\",\"parameters\":[{\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.141\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.143\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.144\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.150\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.insertEntry\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.160\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.161\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.145\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.164\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"},{\"kind\":\"fvar\",\"id\":\"_uniq.110\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.167\"},{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.169\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.170\"}}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.172\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.173\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.175\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.78\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.94\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.185\"}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"borrow\":false},{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.176\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"},{\"kind\":\"fvar\",\"id\":\"_uniq.186\"},{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.188\"}}}]}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"instDecidableEqBool\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.insertEntry\",\"LexLeanBoot.AxiomOutput.lessBytes\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.nameStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.11\",\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.nameStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.15\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.18\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.24\"}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instOfNatNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.nameStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.isWord\",\"LexLeanBoot.AxiomOutput.trimmed\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isWord\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.8\"}}}},\"uses\":[\"Bool\",\"ByteArray\",\"LexLeanBoot.AxiomOutput.isWord\",\"LexLeanBoot.AxiomOutput.trimmed\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"65\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"90\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"97\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"122\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.46\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"95\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.55\"}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.56\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}]}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isLater\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.AxiomOutput.isFirst\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"57\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.inRange\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.43\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"63\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"39\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.64\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.71\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.inRange\",\"LexLeanBoot.AxiomOutput.isFirst\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isWord\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.allDigits\",\"LexLeanBoot.AxiomOutput.fitsWord\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.42\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.41\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.48\",\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.33\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"+\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.103\",\"parameters\":[{\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.fitsWord\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.78\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.84\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.87\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.allDigits\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}]}}}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.59\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.106\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.109\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]}}]}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.allDigits\",\"LexLeanBoot.AxiomOutput.fitsWord\",\"LexLeanBoot.AxiomOutput.significant\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.lastStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.35\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.46\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.49\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.lessBytes\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqOrdering\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.compareBytes\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Ordering\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}}}}}}}}}}}}}}},\"uses\":[\"Array\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Ordering\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqOrdering\",\"ByteArray.mk\",\"LexLeanRuntime.compareBytes\",\"LexLeanRuntime.equal\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.listLength\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"Nat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"HAdd.hAdd\",\"LexLeanCollections.listFold\",\"OfNat.ofNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.26\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.20\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.23\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.21\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.25\"}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.28\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.30\"}}}}}}},\"uses\":[\"Add\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"LexLeanCollections.listFold\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.listed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.axiomList\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.splitLast\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.57\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.axiomList\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.76\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.62\"}}]}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"' depends on axioms: [\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitLast\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.axiomList\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.splitLast\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.located\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"Option.none\",\"Prod.fst\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.afterLocation\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.afterLocation.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.135\",\"parameters\":[{\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.91\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.afterLocation\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isCount\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.105\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.106\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}]}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.117\",\"parameters\":[{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"},{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.129\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.118\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.135\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.140\",\"parameters\":[{\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.139\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.140\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.68\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.149\"},{\"kind\":\"fvar\",\"id\":\"_uniq.151\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.152\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.141\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.153\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.154\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.155\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.156\"}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.158\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.163\",\"parameters\":[{\"id\":\"_uniq.161\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.162\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.163\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\":\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.173\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.174\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.176\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.164\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.175\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.176\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.177\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.178\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.159\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.177\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.178\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.afterLocation\",\"LexLeanBoot.AxiomOutput.isCount\",\"LexLeanBoot.AxiomOutput.splitOnce\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"Except.error\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.error\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.nameMode\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Eq\",\"Nat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.equal\",\"Nat.beq\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.isFirst\",\"LexLeanBoot.AxiomOutput.isLater\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.42\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.60\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isFirst\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.71\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.72\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isLater\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.101\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.102\"}}}]}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}}}]}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.127\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.128\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}}}]}}}}}}}]}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.38\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"Nat.beq\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.isFirst\",\"LexLeanBoot.AxiomOutput.isLater\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.nameStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"Nat.beq\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.AxiomOutput.nameMode\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.AxiomOutput.inRange.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.54\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.74\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.71\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"},{\"kind\":\"fvar\",\"id\":\"_uniq.75\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.nameMode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.79\"}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.87\",\"parameters\":[{\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.86\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.87\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.97\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.99\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.101\"}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}]}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.nameMode\",\"LexLeanBoot.Text.byteAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" is not a Lean name\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.quoted\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parseAuditOutput\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.nil\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.finish\",\"LexLeanBoot.AxiomOutput.scanStep\",\"LexLeanBoot.Text.lines\",\"LexLeanBoot.AxiomOutput.Scan.between\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.20\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.scanStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.lines\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.finish\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.27\"}}}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"LexLeanCollections.listFold\",\"List.nil\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.finish\",\"LexLeanBoot.AxiomOutput.scanStep\",\"LexLeanBoot.Text.lines\",\"LexLeanBoot.AxiomOutput.Scan.between\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsePayload\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Except\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"List.nil\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.listed\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\",\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"LexLeanBoot.AxiomOutput.parsePayload.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.65\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.150\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.102\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.notLean\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.86\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.98\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.99\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.100\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.133\",\"parameters\":[{\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.114\",\"parameters\":[{\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.listed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.113\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"]\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.127\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.130\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.131\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.115\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.130\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.131\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.133\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"' does not depend on any axioms\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"},{\"kind\":\"fvar\",\"id\":\"_uniq.143\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.134\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.146\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.148\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.103\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.148\"}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.150\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"'\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.161\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"discriminant\":\"_uniq.161\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.162\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.163\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.162\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.163\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.165\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.165\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Except\",\"List\",\"Option\",\"PUnit\",\"Prod\",\"String\",\"instDecidableEqBool\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"List.nil\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.isClosedLeanName\",\"LexLeanBoot.AxiomOutput.listed\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.notLean\",\"LexLeanBoot.AxiomOutput.parsed\",\"LexLeanBoot.AxiomOutput.stripPrefix\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.unrecognized\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"Except.ok\",\"Prod.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.ok\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.ok\",\"Prod.mk\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.quoted\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"`\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.refuse\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"Except.error\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.rejected\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Except.error\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Option\",\"Prod\",\"Except.error\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.rejected\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Rejection.mk\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.reversed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.20\",\"parameters\":[{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"borrow\":false},{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.22\"}}}}},\"uses\":[\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.scanStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.continuation\",\"LexLeanBoot.AxiomOutput.envelope\",\"LexLeanBoot.AxiomOutput.extend\",\"LexLeanBoot.AxiomOutput.headOf\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"LexLeanBoot.AxiomOutput.scanStep.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.97\",\"parameters\":[{\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.97\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.151\",\"parameters\":[{\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.114\"},{\"kind\":\"fvar\",\"id\":\"_uniq.125\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.127\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.136\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.132\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unterminated axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.132\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.133\"},{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.134\"},{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.135\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.136\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.continuation\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.145\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.146\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.137\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.146\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.147\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.148\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.148\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.149\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.151\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.209\",\"parameters\":[{\"id\":\"_uniq.157\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.168\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.173\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.169\"},{\"kind\":\"fvar\",\"id\":\"_uniq.172\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.174\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.175\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.173\"},{\"kind\":\"fvar\",\"id\":\"_uniq.174\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.175\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.176\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.183\",\"parameters\":[{\"id\":\"_uniq.180\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.181\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.extend\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.158\"},{\"kind\":\"fvar\",\"id\":\"_uniq.180\"},{\"kind\":\"fvar\",\"id\":\"_uniq.181\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.182\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.183\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.192\",\"parameters\":[{\"id\":\"_uniq.186\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.187\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unrecognized audit line: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.187\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"},{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.headOf\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.158\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.191\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.189\"},{\"kind\":\"fvar\",\"id\":\"_uniq.190\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.191\"}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.193\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.192\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.201\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.envelope\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.201\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.202\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.203\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.193\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.202\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.203\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.204\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.205\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.184\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.204\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.205\"}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.207\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.209\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"LexLeanBoot.AxiomOutput.Scan\",\"result_type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"discriminant\":\"_uniq.89\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"parameters\":[{\"id\":\"_uniq.223\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.224\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.225\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.223\"},{\"kind\":\"fvar\",\"id\":\"_uniq.224\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.225\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"parameters\":[{\"id\":\"_uniq.226\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Record\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.227\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.228\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.229\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.230\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.152\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.226\"},{\"kind\":\"fvar\",\"id\":\"_uniq.227\"},{\"kind\":\"fvar\",\"id\":\"_uniq.228\"},{\"kind\":\"fvar\",\"id\":\"_uniq.229\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.230\"}}},{\"kind\":\"constructor\",\"constructor\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"parameters\":[{\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.232\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"String\",\"instDecidableEqBool\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.beq\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.continuation\",\"LexLeanBoot.AxiomOutput.envelope\",\"LexLeanBoot.AxiomOutput.extend\",\"LexLeanBoot.AxiomOutput.headOf\",\"LexLeanBoot.AxiomOutput.stop\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.trimmed\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.significant\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.zeroStep\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.15\",\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.zeroStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.21\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.22\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.17\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.zeroStep\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.skipWhite\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.32\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.33\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}}}}}]}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.40\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitLast\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lastStep\",\"LexLeanBoot.Text.matchAt\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.30\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.32\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.50\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.lastStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.52\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.55\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.60\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.72\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.75\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.77\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.53\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.84\"}}}}}}}}}}}]}}}}}}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}]}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lastStep\",\"LexLeanBoot.Text.matchAt\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitOnce\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"HAdd.hAdd\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"LexLeanBoot.Text.find\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.AxiomOutput.splitOnce.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.40\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}}}}}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.61\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.find\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"discriminant\":\"_uniq.70\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}]}}}}}}},\"uses\":[\"Add\",\"ByteArray\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"instAddNat\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.Text.find\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.startsWhite\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instOfNatNat\",\"Nat.blt\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.8\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.11\"}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"instOfNatNat\",\"Nat.blt\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stop\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.rejected\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Rejection\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.rejected\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}}},\"uses\":[\"ByteArray\",\"Option\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.rejected\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stripPrefix\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.startsWith\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.startsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.startsWith\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}}}}}}}}}}]}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.tailOf\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Unit\",\"List.nil\",\"LexLeanBoot.AxiomOutput.axiomList.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.37\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.36\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.37\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"List\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"List.nil\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}},{\"kind\":\"constructor\",\"constructor\":\"List.cons\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}}]}}}}}},\"uses\":[\"ByteArray\",\"List\",\"PUnit\",\"List.cons\",\"List.nil\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.terminates\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Option\",\"Unit\",\"Bool.false\",\"Bool.true\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\",\"LexLeanBoot.AxiomOutput.isWord.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.62\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.61\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.62\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\" does not depend on any axioms\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.73\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.63\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.58\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.77\"}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"]\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.stripSuffix\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.90\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}]}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Option\",\"PUnit\",\"String\",\"Bool.false\",\"Bool.true\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanBoot.AxiomOutput.stripSuffix\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.text\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"String\",\"LexLeanRuntime.utf8Encode\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.utf8Encode\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.7\"}}},\"uses\":[\"ByteArray\",\"String\",\"LexLeanRuntime.utf8Encode\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.trimmed\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"LexLeanBoot.AxiomOutput.skipWhite\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.skipWhite\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanBoot.AxiomOutput.dropWhiteEnd\",\"LexLeanBoot.AxiomOutput.skipWhite\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.unrecognized\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.text\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},\"parameters\":[{\"id\":\"_uniq.6\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"String\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"string\",\"value\":\"unrecognized axiom payload: \"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.text\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.cat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.8\"},{\"kind\":\"fvar\",\"id\":\"_uniq.6\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.10\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Except\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.malformed\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.10\"}}}}}},\"uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"String\",\"LexLeanBoot.AxiomOutput.cat\",\"LexLeanBoot.AxiomOutput.malformed\",\"LexLeanBoot.AxiomOutput.text\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.whiteEnding\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"OfNat.ofNat\",\"LexLeanBoot.AxiomOutput.whiteLength\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.44\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.61\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.62\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.131\",\"parameters\":[{\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.90\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.91\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.111\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.127\",\"parameters\":[{\"id\":\"_uniq.120\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.120\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.121\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.122\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.123\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.110\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.125\"}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.113\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.116\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.111\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.127\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.beq\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.131\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.132\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.133\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.56\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.133\"}}}]}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.135\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.136\"}}}]}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.subtract\",\"Nat.beq\",\"Nat.ble\",\"LexLeanBoot.AxiomOutput.whiteLength\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.whiteLength\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\",\"LexLeanBoot.AxiomOutput.byteIs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.102\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.105\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.556\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.130\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.131\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"194\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.141\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.141\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.143\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.144\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.143\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.145\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.154\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"225\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.155\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.154\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.155\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.158\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.158\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.168\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"226\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.169\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.168\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.170\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.169\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.171\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.170\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.172\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.171\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.172\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.173\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.182\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"227\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.183\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.182\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.184\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.183\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.185\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.184\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.186\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.185\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.186\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.187\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.188\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.189\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.188\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.190\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.189\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.190\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.191\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.208\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.209\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.208\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.210\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.209\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.211\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.212\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.211\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.213\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.212\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.214\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.213\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.215\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.216\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.215\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.217\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.216\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.218\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.214\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.219\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.218\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.252\",\"parameters\":[{\"id\":\"_uniq.241\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.242\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.241\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.242\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.243\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.244\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.245\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.244\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.246\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.245\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.246\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.247\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.248\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.249\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.248\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.250\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.249\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.250\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.219\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.220\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.221\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.221\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.222\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.231\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.232\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.231\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.233\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.232\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.234\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.210\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.233\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.235\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.234\"},{\"kind\":\"fvar\",\"id\":\"_uniq.217\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.236\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.235\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.236\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.237\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.238\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.238\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.239\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.252\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.254\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.263\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.264\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.263\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.265\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.264\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.266\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.267\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.266\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.268\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.267\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.269\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.268\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.270\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.271\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.270\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.272\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.271\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.273\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"},{\"kind\":\"fvar\",\"id\":\"_uniq.272\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.274\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.273\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.274\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.275\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.292\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"129\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.293\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.292\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.294\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.293\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.295\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.269\"},{\"kind\":\"fvar\",\"id\":\"_uniq.294\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.296\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.295\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.332\",\"parameters\":[{\"id\":\"_uniq.321\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.322\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.321\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.322\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.323\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.324\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.325\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.324\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.326\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.325\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.326\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.327\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.328\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.329\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.328\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.330\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.329\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.330\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.296\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.297\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.298\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.298\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.299\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.308\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.309\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.308\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.310\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.309\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.311\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.310\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.312\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"159\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.313\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.312\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.314\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.313\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.315\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.311\"},{\"kind\":\"fvar\",\"id\":\"_uniq.314\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.316\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.315\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.316\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.317\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.318\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.318\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.319\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.332\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.333\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.350\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.351\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.350\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.352\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.351\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.353\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.265\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.352\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.354\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"138\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.355\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.354\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.356\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.355\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.357\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIn\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.272\"},{\"kind\":\"fvar\",\"id\":\"_uniq.356\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.358\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.357\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.421\",\"parameters\":[{\"id\":\"_uniq.410\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.411\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.410\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.411\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.412\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.413\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.414\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.413\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.415\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.414\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.415\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.416\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.417\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.418\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.417\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.419\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.418\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.419\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.358\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.359\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.368\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"168\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.369\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.368\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.370\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.369\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.371\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.370\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.372\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.371\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.372\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.373\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.382\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"169\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.383\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.382\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.384\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.383\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.385\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.384\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.386\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.385\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.386\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.387\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.396\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"175\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.397\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.396\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.398\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.397\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.399\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.353\"},{\"kind\":\"fvar\",\"id\":\"_uniq.398\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.400\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.399\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.400\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.401\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.402\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.402\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.403\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.405\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.407\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.409\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.421\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}}]}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.424\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.441\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.442\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.441\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.443\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.442\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.444\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.445\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.444\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.446\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.445\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.447\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.443\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.446\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.448\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"154\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.449\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.448\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.450\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.449\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.451\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.447\"},{\"kind\":\"fvar\",\"id\":\"_uniq.450\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.452\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.451\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.488\",\"parameters\":[{\"id\":\"_uniq.477\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.478\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.477\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.478\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.479\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.480\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.481\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.480\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.482\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.481\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.482\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.483\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.484\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"3\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.485\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.484\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.486\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.485\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.486\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.452\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.453\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.454\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.454\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.455\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.464\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.465\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.464\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.466\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.465\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.467\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.443\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.466\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.468\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"128\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.469\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.468\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.470\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.469\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.471\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.467\"},{\"kind\":\"fvar\",\"id\":\"_uniq.470\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.472\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.471\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.472\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.473\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.474\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.474\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.475\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.488\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.490\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.507\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.508\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.507\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.509\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.508\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.510\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.511\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.510\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.512\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.511\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.513\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.509\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.512\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.514\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"133\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.515\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.514\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.516\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.515\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.517\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.513\"},{\"kind\":\"fvar\",\"id\":\"_uniq.516\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.518\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.517\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.549\",\"parameters\":[{\"id\":\"_uniq.538\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.539\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.538\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.539\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.540\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.541\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.542\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.541\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.543\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.542\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.543\"}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.544\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.545\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"2\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.546\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.545\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.547\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.546\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.547\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.518\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.519\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.528\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"160\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.529\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.528\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.530\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.529\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.531\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.513\"},{\"kind\":\"fvar\",\"id\":\"_uniq.530\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.532\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.531\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.532\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.533\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.534\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.534\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.535\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.537\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.549\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}}}}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.551\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.552\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.553\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.552\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.554\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.553\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.554\"}}}}}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.109\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.110\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.120\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.121\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.122\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"discriminant\":\"_uniq.123\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.124\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.126\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"jump\",\"target\":\"_uniq.556\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]}}]}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIn\",\"LexLeanBoot.AxiomOutput.byteIs\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.zeroStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIs\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.14\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"48\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.AxiomOutput.byteIs\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.35\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}]}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"UInt8\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"Option.none\",\"Option.some\",\"UInt8.instOfNat\",\"LexLeanBoot.AxiomOutput.byteIs\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.byteAt\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"UInt8\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.chomp\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}]}}}}}}}}}}}},\"uses\":[\"Array\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Sub\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.endsWith\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.endsWith\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}]}}}}}}}}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.find\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanBoot.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.80\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.67\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.69\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.75\"}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.77\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.82\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.85\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.83\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.89\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.102\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.104\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.105\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.106\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.107\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}]}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanBoot.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.lineStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"UInt8.instOfNat\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.chomp\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.chomp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}}}}}}}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.122\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.chomp\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.lines\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.lineStep\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.lineStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Prod.mk\",\"LexLeanBoot.Text.lineStep\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.matchAt\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.reverse\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}},\"uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.sliceOr\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.splitOn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Prod\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.splitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.splitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanBoot.Text.reverse\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.splitStep\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.splitStep\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.sliceOr\",\"LexLeanBoot.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}}}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanBoot.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanBoot.Text.byteAt\",\"LexLeanBoot.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanBoot.Text.startsWith\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"OfNat.ofNat\",\"LexLeanBoot.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}]}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.fromInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.maximum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.minimum\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Fixed.toToMathInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Fixed\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.isZero\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.quotient\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Quotient.remainder\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Quotient\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.ToMathInt.toInt\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.ToMathInt\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.axioms\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.declaration\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.expected\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanBoot.AxiomOutput.Record\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Record.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Rejection.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.between\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.casesOn\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.rec\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.inside\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.rec\",\"kind\":\"recursor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"recursor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.Scan.stopped\",\"kind\":\"constructor\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.afterLocation.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.auditStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\",\"LexLeanBoot.AxiomOutput.Rejection\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.axiomList.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Unit\",\"List.casesOn\",\"List.cons\",\"List.nil\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.collectStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.extend.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Except\",\"List\",\"Prod\",\"Except.casesOn\",\"Except.error\",\"Except.ok\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.inRange.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom._f\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"LexLeanBoot.AxiomOutput.lessBytes\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\",\"LexLeanBoot.AxiomOutput.insertAxiom.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertAxiom.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry._f\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Option\",\"Prod\",\"Unit\",\"instDecidableEqBool\",\"ite\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"List.below\",\"List.cons\",\"List.nil\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"LexLeanBoot.AxiomOutput.lessBytes\",\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"LexLeanBoot.AxiomOutput.insertEntry.match_3\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"Prod\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.insertEntry.match_3\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Prod\",\"List.casesOn\",\"List.cons\",\"List.nil\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.isWord.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.parsePayload.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.scanStep.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"LexLeanBoot.AxiomOutput.Record\",\"LexLeanBoot.AxiomOutput.Rejection\",\"LexLeanBoot.AxiomOutput.Scan\",\"LexLeanBoot.AxiomOutput.Scan.between\",\"LexLeanBoot.AxiomOutput.Scan.casesOn\",\"LexLeanBoot.AxiomOutput.Scan.inside\",\"LexLeanBoot.AxiomOutput.Scan.stopped\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.AxiomOutput.splitOnce.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.AxiomOutput\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.Text.sliceOr.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanBoot.Text.spaceAt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanBoot.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Except\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Int\",\"kind\":\"inductive\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ord\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Ordering\",\"kind\":\"inductive\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"String\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt32\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqOrdering\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt8\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.not\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.toList\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Except.error\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Except.ok\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Except\"},{\"name\":\"Int.decLt\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.instSub\",\"kind\":\"definition\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Int.ofNat\",\"kind\":\"constructor\",\"module\":\"Init.Data.Int.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"Int\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.beq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLt\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.div\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.mod\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"String.toUTF8\",\"kind\":\"axiom\",\"module\":\"Init.Data.String.Defs\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt32.toNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.complement\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.instOrd\",\"kind\":\"definition\",\"module\":\"Init.Data.Ord.UInt\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.land\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.lor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.ofInt\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.ofNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.shiftLeft\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.shiftRight\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.toNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"UInt8.xor\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"8936693ae9a91f38acfc70d3ebc0d4683efcc54907e455298d72339e1e36cead","tool":"lean"} diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0.lean b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0.lean similarity index 99% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0.lean rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0.lean index 2433026d1..55688cd3b 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0.lean +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0 +namespace LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -95,4 +95,4 @@ def denote (raw : ByteArray) : _root_.LexLeanPreservation.Obs := theorem root (raw : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes raw)] (_root_.LexLeanPreservation.Rel (__fits_0 raw) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanBoot.AxiomOutput.isClosedLeanName raw))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 raw) -end LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0 +end LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0 diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/Compose/RustStd.lex.tex b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/Compose/RustStd.lex.tex similarity index 93% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/Compose/RustStd.lex.tex rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/Compose/RustStd.lex.tex index 3007e55b3..4879ae99b 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/Compose/RustStd.lex.tex +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0, - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd, + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0, + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.root : @827 := @828 { - all: [LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.root], +theorem LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.root : @827 := @828 { + all: [LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.program -@1 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.krate -@2 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.flags +@0 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.program +@1 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.krate +@2 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.flags @3 := ByteArray @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -72,7 +72,7 @@ @87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 @92 := List.getD.{0} @72 @74 @61 @87 @96 := fun (__e_n : @57) => - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.root @17 @61 + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.root @17 @61 @97 := LexLeanPreservation.Rust.WTL @105 := {p : @8} -> {c : @9} -> {A : @10} -> @97 @14 @4 @17 @53 @77 @107 := LexLeanPreservation.Rust.wtl_nil @0 @@ -159,13 +159,13 @@ @269 := @263 @121 @270 := @122 @56 @271 := @270 @259 -@272 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.denote +@272 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.denote @273 := @272 @4 -@274 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.__fits_0 +@274 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.__fits_0 @275 := @274 @4 @277 := LexLeanBoot.AxiomOutput.isClosedLeanName @4 @279 := LexLeanTarget.TargetSyntax.Value.bool @277 -@281 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.root @4 +@281 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.root @4 @282 := Bool @283 := Ne.{1} @284 := LexLeanPreservation.Obs diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/RustStd.lean b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/RustStd.lean similarity index 99% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/RustStd.lean rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/RustStd.lean index cbce92caa..e18a8295c 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/RustStd.lean +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd +namespace LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -96,4 +96,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd +end LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1.lean b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1.lean similarity index 99% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1.lean rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1.lean index 36565d664..a9634a201 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1.lean +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1.lean @@ -12,7 +12,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1 +namespace LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [{ constructors := [[.bytes, (.option .bytes)]] }, @@ -837,4 +837,4 @@ def denote (stdout : ByteArray) (expected : (List ByteArray)) : _root_.LexLeanPr theorem root (stdout : ByteArray) (expected : (List ByteArray)) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes stdout), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) expected)] (_root_.LexLeanPreservation.Rel (__fits_0 stdout expected) ((_root_.LexLeanPreservation.encExcept __enc_0 (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bytes (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (LexLeanBoot.AxiomOutput.parseAuditOutput stdout expected))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 stdout expected) -end LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1 +end LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1 diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/Compose/RustStd.lex.tex b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/Compose/RustStd.lex.tex similarity index 95% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/Compose/RustStd.lex.tex rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/Compose/RustStd.lex.tex index 0ae77d850..a81ca781e 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/Compose/RustStd.lex.tex +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/Compose/RustStd.lex.tex @@ -1,47 +1,47 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd} +\title{Certificate E LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1, - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd, + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1, + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_0 : @16 := @541 { - all: [LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_0], +theorem LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_0 : @16 := @541 { + all: [LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_0], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_2 : @549 := @873 { - all: [LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_2], +theorem LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_2 : @549 := @873 { + all: [LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_2], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_1 : @881 := @1454 { - all: [LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_1], +theorem LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_1 : @881 := @1454 { + all: [LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_1], class: false, generated: false, policy: exact{axioms: [propext]}, transparency: semireducible } -theorem LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.root : @2180 := @2181 { - all: [LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.root], +theorem LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.root : @2180 := @2181 { + all: [LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.program -@1 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.krate -@2 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.flags +@0 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.program +@1 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.krate +@2 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.flags @3 := LexLeanBoot.AxiomOutput.Rejection @4 := #0 -@5 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.__enc_0 +@5 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.__enc_0 @6 := @5 @4 @7 := LexLeanPreservation.Rust.WT @8 := LexLeanTarget.TargetSyntax.Ty.adt @@ -308,7 +308,7 @@ @540 := @13 (@505 @185) @10 @541 := fun (__s : @3) => @537 @542 := LexLeanBoot.AxiomOutput.Record -@543 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.__enc_2 +@543 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.__enc_2 @544 := @543 @4 @545 := 2 @546 := @8 @545 @@ -462,7 +462,7 @@ @872 := @13 (@505 @643) @546 @873 := fun (__s : @542) => @869 @874 := LexLeanBoot.AxiomOutput.Scan -@876 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.__enc_1 @4 +@876 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.__enc_1 @4 @877 := 1 @878 := @8 @877 @880 := @13 @876 @878 @@ -473,7 +473,7 @@ @885 := @884 @32 @886 := @564 @546 @889 := fun (__x : @542) => - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_2 @4 + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_2 @4 @890 := @601 @542 @891 := (a._@._internal._hyg.#0 : @542) -> @72 @892 := (x : @542) -> @139 @@ -711,7 +711,7 @@ @1340 := @1335 @1303 @1343 := @13 (@1310 @1098) @878 @1347 := fun (__x0 : @893) => fun (__x1 : @610) => fun (__x2 : @27) => fun (__x3 : @151) => @1340 -@1349 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_0 @4 +@1349 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_0 @4 @1351 := @181 @6 @180 @1352 := @187 @10 @1353 := @1352 @186 @@ -781,7 +781,7 @@ @1488 := LexLeanTarget.TargetSyntax.Function.mk @1478 @186 @1479 @1483 @1493 := List.getD.{0} @1475 @1477 @9 @1488 @1497 := fun (__e_n : @420) => - LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.root @4 @9 + LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.root @4 @9 @1498 := @285 @956 @1505 := {t : @74} -> {vs : @221} -> {ts : @222} -> (h : @1224 @30) -> (hs : @289) -> @1229 @238 @1506 := @1498 @565 @@ -817,9 +817,9 @@ @1565 := @1560 @1524 @1566 := @217 @1457 @1567 := @1566 @1556 -@1568 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.denote +@1568 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.denote @1570 := @1568 @30 @32 -@1571 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.__fits_0 +@1571 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.__fits_0 @1573 := @1571 @30 @32 @1576 := LexLeanBoot.AxiomOutput.parseAuditOutput @30 @32 @1578 := @1458 @27 @610 @@ -827,7 +827,7 @@ @1584 := LexLeanPreservation.encPair @27 @610 @21 @562 @1586 := @560 @1578 @1584 @1592 := LexLeanPreservation.encExcept @3 @1579 @5 @1586 @1576 -@1595 := LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.root @30 @32 +@1595 := LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.root @30 @32 @1596 := Bool @1597 := Ne.{1} @1598 := LexLeanPreservation.Obs diff --git a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/RustStd.lean b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/RustStd.lean similarity index 99% rename from bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/RustStd.lean rename to bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/RustStd.lean index a0798a8b5..ea28c8026 100644 --- a/bootstrap/expected/verify/preserve/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/RustStd.lean +++ b/bootstrap/expected/verify/preserve/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd +namespace LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -839,4 +839,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd +end LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd diff --git a/bootstrap/expected/verify/preserve/audit.txt b/bootstrap/expected/verify/preserve/audit.txt index 55e02ef79..351b7f09f 100644 --- a/bootstrap/expected/verify/preserve/audit.txt +++ b/bootstrap/expected/verify/preserve/audit.txt @@ -7737,23 +7737,23 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_1' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/bootstrap/expected/verify/preserve/preservation.json b/bootstrap/expected/verify/preserve/preservation.json index 053822da8..2803afb80 100644 --- a/bootstrap/expected/verify/preserve/preservation.json +++ b/bootstrap/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":34133,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0","program":{"byte_length":9488,"sha256":"730de4e60a1096efe498df077205f9916491d21aa78c6f1a197a1898349209f2"},"renderings":[{"byte_length":43700,"composed":{"byte_length":12124,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd","sha256":"9dfa6e21645d45c6c80ceef53c7206b70cc9d76101ed7876436071d9f21ba102","theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.root"},"crate":{"byte_length":16737,"sha256":"7ff8ac9599486a35468e5ea4475ed877f8429cd453b1cb1ea35b750a24587d99"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd","sha256":"8128aedd6d5c6646a6ef6552c310ee1b48f2cb08ed813509dc527b2cfdb4b569","target":"rust-std","theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.root"}],"root":"LexLeanBoot.AxiomOutput.isClosedLeanName","sha256":"45ccb28606907864f4740bc44c468ef8d3fe0cec4a9e679abecd2580cf1dbe13","targets":["rust-std"],"theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.root"},{"byte_length":556512,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1","program":{"byte_length":115984,"sha256":"c494532214aa6b635eeb3efaed879328a4f5370efdc9d5079105c177d5f4ede8"},"renderings":[{"byte_length":625009,"composed":{"byte_length":33573,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd","sha256":"3ba46eeade878347679eb66e16d719927f008cb7a1a787b47cd09f384a2f5c87","theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.root"},"crate":{"byte_length":67653,"sha256":"618126735f4e48ee1b62cfb47ba39d8bbb3636b876e6edd10f6d45ac079c7dd3"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd","sha256":"218ae6d12bf4bad20193687bd439eca24b58aa74d61e54aa9194f630eb85ba62","target":"rust-std","theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.root"}],"root":"LexLeanBoot.AxiomOutput.parseAuditOutput","sha256":"c4b5646e8fa7fbafa223c81d65c327d31e8ee0673384b9ff8612cdc9f8b48c00","targets":["rust-std"],"theorem":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":34133,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0","program":{"byte_length":9488,"sha256":"730de4e60a1096efe498df077205f9916491d21aa78c6f1a197a1898349209f2"},"renderings":[{"byte_length":43700,"composed":{"byte_length":12124,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd","sha256":"25ea0b1bd659e1a137af0f5cb7fa278a83ff4b1c649886abb249c0824adb1def","theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.root"},"crate":{"byte_length":16737,"sha256":"7ff8ac9599486a35468e5ea4475ed877f8429cd453b1cb1ea35b750a24587d99"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd","sha256":"757eac64f2344f58593fc30c48a81405a45ffc923fcfd659dedc295aeb01dd80","target":"rust-std","theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.root"}],"root":"LexLeanBoot.AxiomOutput.isClosedLeanName","sha256":"c69095cbf64ce32141a0506723f330c269f83042a3e5025648a165c99f726496","targets":["rust-std"],"theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.root"},{"byte_length":556512,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1","program":{"byte_length":115984,"sha256":"c494532214aa6b635eeb3efaed879328a4f5370efdc9d5079105c177d5f4ede8"},"renderings":[{"byte_length":625009,"composed":{"byte_length":33573,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd","sha256":"06c5751ec739c9ba5d7b939f7a0782b872f9bc029013d41d093fe9366a20f267","theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.root"},"crate":{"byte_length":67653,"sha256":"618126735f4e48ee1b62cfb47ba39d8bbb3636b876e6edd10f6d45ac079c7dd3"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd","sha256":"b63b61da2a2d4edeeb081d10c6d066ca2959ac6c0aadc76dcff899b4043ebfab","target":"rust-std","theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.root"}],"root":"LexLeanBoot.AxiomOutput.parseAuditOutput","sha256":"9d983e6f4c077dbbee22f00c3f6684d6283f44b330ef695a01218b88d936ed2c","targets":["rust-std"],"theorem":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.root"}],"spec":"lexlean/preservation/1"} diff --git a/bootstrap/expected/verify/probe/LexLeanProbe.Padb40bbfc73b1dc6b7a95dab0c348a27.lean b/bootstrap/expected/verify/probe/LexLeanProbe.P5ba510b7049a3e59c5f1ffb1f0a6611d.lean similarity index 100% rename from bootstrap/expected/verify/probe/LexLeanProbe.Padb40bbfc73b1dc6b7a95dab0c348a27.lean rename to bootstrap/expected/verify/probe/LexLeanProbe.P5ba510b7049a3e59c5f1ffb1f0a6611d.lean diff --git a/bootstrap/expected/verify/probe/process.json b/bootstrap/expected/verify/probe/process.json index 94fc9a065..e84c0aa60 100644 --- a/bootstrap/expected/verify/probe/process.json +++ b/bootstrap/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Padb40bbfc73b1dc6b7a95dab0c348a27.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Padb40bbfc73b1dc6b7a95dab0c348a27","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P5ba510b7049a3e59c5f1ffb1f0a6611d.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P5ba510b7049a3e59c5f1ffb1f0a6611d","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json similarity index 72% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json index 027d449a4..568cf5e66 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json similarity index 71% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json index 37ca84e7a..f50d89643 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json similarity index 55% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json index c2b2a6f1a..511a9170c 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json similarity index 72% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json index 87f97e105..9934f945f 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json similarity index 71% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json index 69f3274be..006f1ede6 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json similarity index 55% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json rename to bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json index f8efb02d9..f83a4199c 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json +++ b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json deleted file mode 100644 index 0379176e8..000000000 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json deleted file mode 100644 index 9a0c6d6bb..000000000 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json deleted file mode 100644 index 24019f251..000000000 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json b/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json deleted file mode 100644 index e921328cc..000000000 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 1037360f3..6d3ad0be7 100644 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.__wt_1' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"bb331faafeb4b8833855053a7ecb8fc8e1ac22fb58a4a7bb1d64e1c7de908e35","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.__wt_1' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"cb5e66ad9f6e159b3db848719f8d394d2fb2a1686a78c95c12bf79b8726808bb","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json similarity index 57% rename from bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json rename to bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json index 7098b7104..0e7e4b63f 100644 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json similarity index 55% rename from bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json rename to bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json index ccf290554..6194f93f3 100644 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd.json +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json new file mode 100644 index 000000000..d77e21969 --- /dev/null +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json similarity index 57% rename from stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json rename to bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json index 820a76673..bed778d98 100644 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json similarity index 55% rename from bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json rename to bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json index 800c23f38..36b4ee93e 100644 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd.json +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json new file mode 100644 index 000000000..0c869348b --- /dev/null +++ b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C5ba510b7049a3e59c5f1ffb1f0a6611d/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5ba510b7049a3e59c5f1ffb1f0a6611d.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json deleted file mode 100644 index 2a19ce569..000000000 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json b/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json deleted file mode 100644 index d9ffe7ddf..000000000 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/lexlean.lock b/bootstrap/lexlean.lock index 3777d8347..361203945 100644 --- a/bootstrap/lexlean.lock +++ b/bootstrap/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0" +compiler_semantics = "91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a" project_config_sha256 = "7165f2fed5d1b4ece471ea2b9fdbf107c48272617d8bd5d3875f719e2aecc0ef" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Collections.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.lean diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.process.json similarity index 97% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.process.json index a6a12d905..a5b73d054 100644 --- a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.process.json similarity index 95% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.process.json index 8b17b7d17..1318263bf 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Laws","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.lessThan._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.lessThan.eq_1' depends on axioms: [propext]\n'LexLeanCollections.listFold.eq_1' does not depend on any axioms\n'LexLeanLaws.append_list' does not depend on any axioms\n'LexLeanLaws.length_list' does not depend on any axioms\n'LexLeanLaws.lessThan_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int16' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int32' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int64' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_int8' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.lessThan_nat' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint16' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint32' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint64' depends on axioms: [propext]\n'LexLeanLaws.lessThan_uint8' depends on axioms: [propext]\n'LexLeanLaws.listFold_add_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_add_nat_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_cons' does not depend on any axioms\n'LexLeanLaws.listFold_extend' depends on axioms: [propext]\n'LexLeanLaws.listFold_fusion' does not depend on any axioms\n'LexLeanLaws.listFold_nil' does not depend on any axioms\n'LexLeanLaws.listFold_pair' does not depend on any axioms\n'LexLeanLaws.listFold_prepend' depends on axioms: [propext]\n'LexLeanLaws.listFold_sub_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.listFold_sub_int_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.mapEntries_self' does not depend on any axioms\n'LexLeanLaws.mapFold_listFold' does not depend on any axioms\n'LexLeanLaws.mapSize_length' does not depend on any axioms\n'LexLeanLaws.quotient_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.quotient_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_int' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.remainder_nat' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.setElements_self' does not depend on any axioms\n'LexLeanLaws.setFold_listFold' does not depend on any axioms\n'LexLeanLaws.setSize_length' does not depend on any axioms\n'LexLeanLaws.sumInt' does not depend on any axioms\n'LexLeanLaws.sumInt._f' does not depend on any axioms\n'LexLeanLaws.sumInt._sunfold' does not depend on any axioms\n'LexLeanLaws.sumInt._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_1' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_2' does not depend on any axioms\n'LexLeanLaws.sumInt.eq_def' does not depend on any axioms\n'LexLeanLaws.sumInt_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_cons' does not depend on any axioms\n'LexLeanLaws.sumInt_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul' depends on axioms: [propext]\n'LexLeanLaws.sumInt_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_mul_self' depends on axioms: [propext]\n'LexLeanLaws.sumInt_neg' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_neg_self' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_nil' does not depend on any axioms\n'LexLeanLaws.sumInt_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumInt_sub' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat' does not depend on any axioms\n'LexLeanLaws.sumNat._f' does not depend on any axioms\n'LexLeanLaws.sumNat._sunfold' does not depend on any axioms\n'LexLeanLaws.sumNat._unsafe_rec' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_1' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_2' does not depend on any axioms\n'LexLeanLaws.sumNat.eq_def' does not depend on any axioms\n'LexLeanLaws.sumNat.match_1' does not depend on any axioms\n'LexLeanLaws.sumNat_add' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_append' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_cons' does not depend on any axioms\n'LexLeanLaws.sumNat_const' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul' does not depend on any axioms\n'LexLeanLaws.sumNat_mul_right' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_mul_self' does not depend on any axioms\n'LexLeanLaws.sumNat_nil' does not depend on any axioms\n'LexLeanLaws.sumNat_perm' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.sumNat_reverse' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tdiv_ediv' depends on axioms: [propext, Quot.sound]\n'LexLeanLaws.tmod_emod' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.quotient.eq_1' does not depend on any axioms\n'LexLeanRuntime.remainder.eq_1' does not depend on any axioms\n","stdout_sha256":"a4ba2d39c9cdfd5e40c41c5ccf4726d937fd192fc042b74bb56cc0651e28919e","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.process.json similarity index 90% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.process.json index 46605066e..38cbf6302 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Models","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanModels.Agreement' does not depend on any axioms\n'LexLeanModels.Complete1' does not depend on any axioms\n'LexLeanModels.Complete2' does not depend on any axioms\n'LexLeanModels.Complete4' does not depend on any axioms\n'LexLeanModels.Equivalent' does not depend on any axioms\n'LexLeanModels.EquivalentStep' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoInvariant' does not depend on any axioms\n'LexLeanModels.EquivalentStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.EquivalentStepTotal' does not depend on any axioms\n'LexLeanModels.EquivalentTotal' does not depend on any axioms\n'LexLeanModels.Initial' does not depend on any axioms\n'LexLeanModels.Preserves' does not depend on any axioms\n'LexLeanModels.PreservesTotal' does not depend on any axioms\n'LexLeanModels.Satisfies' does not depend on any axioms\n'LexLeanModels.SatisfiesStep' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoInvariant' does not depend on any axioms\n'LexLeanModels.SatisfiesStepNoPrecondition' does not depend on any axioms\n'LexLeanModels.SatisfiesStepTotal' does not depend on any axioms\n'LexLeanModels.SatisfiesTotal' does not depend on any axioms\n'LexLeanModels.Sound1' does not depend on any axioms\n'LexLeanModels.Sound2' does not depend on any axioms\n'LexLeanModels.Sound4' does not depend on any axioms\n'LexLeanModels.encodeInt' does not depend on any axioms\n'LexLeanModels.inRange' does not depend on any axioms\n'LexLeanModels.linesMatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanModels.tensorMatches' does not depend on any axioms\n'LexLeanModels.utf8Char' does not depend on any axioms\n","stdout_sha256":"43ad1c715570458672aedc9abb1691012eef870f5b804f1e230abb890e49ffee","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.process.json similarity index 98% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.process.json index c2cc38853..6009a5a33 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.process.json similarity index 94% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.process.json index e99dfed26..7df63150e 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanRuntime.Reasoning","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanReasoning.All' does not depend on any axioms\n'LexLeanReasoning.All.below' does not depend on any axioms\n'LexLeanReasoning.All.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.brecOn' does not depend on any axioms\n'LexLeanReasoning.All.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.recOn' does not depend on any axioms\n'LexLeanReasoning.Complete' does not depend on any axioms\n'LexLeanReasoning.Found' does not depend on any axioms\n'LexLeanReasoning.Found.match_1' does not depend on any axioms\n'LexLeanReasoning.Preserves' does not depend on any axioms\n'LexLeanReasoning.Reaches' does not depend on any axioms\n'LexLeanReasoning.SearchOk' does not depend on any axioms\n'LexLeanReasoning.Sound' does not depend on any axioms\n'LexLeanReasoning.Star' does not depend on any axioms\n'LexLeanReasoning.Star.below' does not depend on any axioms\n'LexLeanReasoning.Star.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.brecOn' does not depend on any axioms\n'LexLeanReasoning.Star.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.recOn' does not depend on any axioms\n'LexLeanReasoning.allAppend' does not depend on any axioms\n'LexLeanReasoning.allFold' does not depend on any axioms\n'LexLeanReasoning.allHead' does not depend on any axioms\n'LexLeanReasoning.allSingle' does not depend on any axioms\n'LexLeanReasoning.allTail' does not depend on any axioms\n'LexLeanReasoning.bltSucc' does not depend on any axioms\n'LexLeanReasoning.capAll' does not depend on any axioms\n'LexLeanReasoning.capBound' does not depend on any axioms\n'LexLeanReasoning.checked' does not depend on any axioms\n'LexLeanReasoning.foldInvariant' does not depend on any axioms\n'LexLeanReasoning.foldSnoc' does not depend on any axioms\n'LexLeanReasoning.freshAll' does not depend on any axioms\n'LexLeanReasoning.guarded' does not depend on any axioms\n'LexLeanReasoning.guardedRank' does not depend on any axioms\n'LexLeanReasoning.iterateUntilBound' does not depend on any axioms\n'LexLeanReasoning.iterateUntilCount' does not depend on any axioms\n'LexLeanReasoning.iterateUntilGrowth' does not depend on any axioms\n'LexLeanReasoning.iterateUntilInvariant' does not depend on any axioms\n'LexLeanReasoning.iterateUntilSimulate' does not depend on any axioms\n'LexLeanReasoning.iterateUntilStops' does not depend on any axioms\n'LexLeanReasoning.lengthSnoc' does not depend on any axioms\n'LexLeanReasoning.noneSome' does not depend on any axioms\n'LexLeanReasoning.peakBound' does not depend on any axioms\n'LexLeanReasoning.reachesStart' does not depend on any axioms\n'LexLeanReasoning.searchStart' does not depend on any axioms\n'LexLeanReasoning.starPreserves' does not depend on any axioms\n'LexLeanReasoning.zeroLe' does not depend on any axioms\n","stdout_sha256":"bcad061b4e8b3848b9d6815070631b4088a7b6b1512ab5c741c66c6dea825fee","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanRuntime.Reasoning","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanReasoning.All' does not depend on any axioms\n'LexLeanReasoning.All.below' does not depend on any axioms\n'LexLeanReasoning.All.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.brecOn' does not depend on any axioms\n'LexLeanReasoning.All.casesOn' does not depend on any axioms\n'LexLeanReasoning.All.recOn' does not depend on any axioms\n'LexLeanReasoning.Complete' does not depend on any axioms\n'LexLeanReasoning.Found' does not depend on any axioms\n'LexLeanReasoning.Found.match_1' does not depend on any axioms\n'LexLeanReasoning.Preserves' does not depend on any axioms\n'LexLeanReasoning.Reaches' does not depend on any axioms\n'LexLeanReasoning.SearchOk' does not depend on any axioms\n'LexLeanReasoning.Sound' does not depend on any axioms\n'LexLeanReasoning.Star' does not depend on any axioms\n'LexLeanReasoning.Star.below' does not depend on any axioms\n'LexLeanReasoning.Star.below.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.brecOn' does not depend on any axioms\n'LexLeanReasoning.Star.casesOn' does not depend on any axioms\n'LexLeanReasoning.Star.recOn' does not depend on any axioms\n'LexLeanReasoning.allAppend' does not depend on any axioms\n'LexLeanReasoning.allFold' does not depend on any axioms\n'LexLeanReasoning.allHead' does not depend on any axioms\n'LexLeanReasoning.allSingle' does not depend on any axioms\n'LexLeanReasoning.allTail' does not depend on any axioms\n'LexLeanReasoning.bltSucc' does not depend on any axioms\n'LexLeanReasoning.capAll' does not depend on any axioms\n'LexLeanReasoning.capBound' does not depend on any axioms\n'LexLeanReasoning.checked' does not depend on any axioms\n'LexLeanReasoning.foldInvariant' does not depend on any axioms\n'LexLeanReasoning.foldSnoc' does not depend on any axioms\n'LexLeanReasoning.freshAll' does not depend on any axioms\n'LexLeanReasoning.guarded' does not depend on any axioms\n'LexLeanReasoning.guardedRank' does not depend on any axioms\n'LexLeanReasoning.iterateUntilBound' does not depend on any axioms\n'LexLeanReasoning.iterateUntilCount' does not depend on any axioms\n'LexLeanReasoning.iterateUntilGrowth' does not depend on any axioms\n'LexLeanReasoning.iterateUntilInvariant' does not depend on any axioms\n'LexLeanReasoning.iterateUntilSimulate' does not depend on any axioms\n'LexLeanReasoning.iterateUntilStops' does not depend on any axioms\n'LexLeanReasoning.lengthSnoc' does not depend on any axioms\n'LexLeanReasoning.noneSome' does not depend on any axioms\n'LexLeanReasoning.peakBound' does not depend on any axioms\n'LexLeanReasoning.reachesStart' does not depend on any axioms\n'LexLeanReasoning.searchStart' does not depend on any axioms\n'LexLeanReasoning.starPreserves' does not depend on any axioms\n'LexLeanReasoning.zeroLe' does not depend on any axioms\n","stdout_sha256":"bcad061b4e8b3848b9d6815070631b4088a7b6b1512ab5c741c66c6dea825fee","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.process.json similarity index 97% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.process.json index c33f3d81a..dd15742d8 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.BudgetOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.BudgetOracle.Burn.apply' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Burn.apply_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Burn.candidates' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.conclusion' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.guard' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Drained.sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Empty' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Ledger' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.account' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.answer' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.attempts' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude_accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.explained' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.extract' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.fire_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.firings_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.follow' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.next' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.next_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.observe' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay_fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.run_state' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.run_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.saturate' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.select' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.start' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_count' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_fired' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_none' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_some' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.verdict' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Remaining' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Ledger' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.account' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.answer' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.attempts' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude_accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.explained' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.extract' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.fire_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.firings_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.follow' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.next' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.next_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.observe' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay_fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.run_state' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.run_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.saturate' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.saturates' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.select' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.start' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_count' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_fired' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_none' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_some' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.verdict' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spent' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.apply' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Tick.apply_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Tick.conclusion' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.guard' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.allowance_bound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.burn_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.burn_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.emptyCheck' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.empty_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.tick_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.tick_sound' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"59007df9d3aac13b14aaf31eaed78191fe1dd3bed8cf0c08553de02edaf64988","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.BudgetOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.BudgetOracle.Burn.apply' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Burn.apply_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Burn.candidates' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.conclusion' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Burn.guard' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Drained.sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Empty' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Ledger' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.Step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.account' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.answer' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.attempts' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude_accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.explained' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Refund.extract' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.fire_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.firings_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.follow' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.next' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.next_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.observe' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay_fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.replay_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.run_state' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.run_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.saturate' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Refund.select' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.start' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_count' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_fired' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_none' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_some' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.step_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.verdict' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Refund.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Remaining' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Ledger' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.Step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.account' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.answer' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.attempts' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude_accept' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.explained' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spend.extract' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.fire_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.firings_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.follow' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.next' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.next_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.observe' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay_fire' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.replay_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.run' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.run_state' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.run_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.saturate' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.saturate_derivation' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.saturates' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Spend.select' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.start' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_count' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_fired' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_none' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_some' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.step_trace' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.verdict' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Spend.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.Spent' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.apply' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Tick.apply_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.Tick.conclusion' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.Tick.guard' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.allowance_bound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.burn_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.burn_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.emptyCheck' does not depend on any axioms\n'LexLeanTarget.BudgetOracle.empty_sound' depends on axioms: [propext]\n'LexLeanTarget.BudgetOracle.tick_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.BudgetOracle.tick_sound' depends on axioms: [propext, Quot.sound]\n","stdout_sha256":"59007df9d3aac13b14aaf31eaed78191fe1dd3bed8cf0c08553de02edaf64988","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.process.json similarity index 96% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.process.json index f41f54312..287f7ad88 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Certification","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Certification.Bridge' does not depend on any axioms\n'LexLeanTarget.Certification.Certificate' does not depend on any axioms\n'LexLeanTarget.Certification.Certified' does not depend on any axioms\n'LexLeanTarget.Certification.Established' does not depend on any axioms\n'LexLeanTarget.Certification.Fact' does not depend on any axioms\n'LexLeanTarget.Certification.Obligation' does not depend on any axioms\n'LexLeanTarget.Certification.Premise' does not depend on any axioms\n'LexLeanTarget.Certification.Refusal' does not depend on any axioms\n'LexLeanTarget.Certification.Route' does not depend on any axioms\n'LexLeanTarget.Certification.Schema' does not depend on any axioms\n'LexLeanTarget.Certification.Verdict' does not depend on any axioms\n'LexLeanTarget.Certification.allBelow' does not depend on any axioms\n'LexLeanTarget.Certification.allLists' does not depend on any axioms\n'LexLeanTarget.Certification.allLong' does not depend on any axioms\n'LexLeanTarget.Certification.allShorter' does not depend on any axioms\n'LexLeanTarget.Certification.argumentStatus' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.armIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.armsIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.ascending' does not depend on any axioms\n'LexLeanTarget.Certification.bridgePosition' does not depend on any axioms\n'LexLeanTarget.Certification.certificateReductionsPreserve' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.cheaperObservation' does not depend on any axioms\n'LexLeanTarget.Certification.check' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.claimShape' does not depend on any axioms\n'LexLeanTarget.Certification.eligible' does not depend on any axioms\n'LexLeanTarget.Certification.establishedFrom' does not depend on any axioms\n'LexLeanTarget.Certification.exprIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.exprsIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.factAt' does not depend on any axioms\n'LexLeanTarget.Certification.factRows' does not depend on any axioms\n'LexLeanTarget.Certification.factsOf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.firstSmaller' does not depend on any axioms\n'LexLeanTarget.Certification.frontierPosition' does not depend on any axioms\n'LexLeanTarget.Certification.frontierVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.improves' does not depend on any axioms\n'LexLeanTarget.Certification.isList' does not depend on any axioms\n'LexLeanTarget.Certification.isLong' does not depend on any axioms\n'LexLeanTarget.Certification.isNormal' does not depend on any axioms\n'LexLeanTarget.Certification.isShorter' does not depend on any axioms\n'LexLeanTarget.Certification.keepsObservation' does not depend on any axioms\n'LexLeanTarget.Certification.lowerPosition' does not depend on any axioms\n'LexLeanTarget.Certification.lowerVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.natAt' does not depend on any axioms\n'LexLeanTarget.Certification.normalityVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.pairRelation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.pickFrom' does not depend on any axioms\n'LexLeanTarget.Certification.plansIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.positionOf' does not depend on any axioms\n'LexLeanTarget.Certification.premiseFact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.reductionVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.reductionsPreserve' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.representationVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.rewrite' does not depend on any axioms\n'LexLeanTarget.Certification.rowsOfMembers' does not depend on any axioms\n'LexLeanTarget.Certification.sameObjective' does not depend on any axioms\n'LexLeanTarget.Certification.sameObservations' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.sameObservationsAt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.sameScope' does not depend on any axioms\n'LexLeanTarget.Certification.scanBridge' does not depend on any axioms\n'LexLeanTarget.Certification.scanFrontier' does not depend on any axioms\n'LexLeanTarget.Certification.scanLower' does not depend on any axioms\n'LexLeanTarget.Certification.scanReduction' does not depend on any axioms\n'LexLeanTarget.Certification.selectorAt' does not depend on any axioms\n'LexLeanTarget.Certification.sizesOf' does not depend on any axioms\n'LexLeanTarget.Certification.staticCharge' does not depend on any axioms\n'LexLeanTarget.Certification.staticSize' does not depend on any axioms\n'LexLeanTarget.Certification.strictlyCheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.strictlyCheaperAt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.valueAt' does not depend on any axioms\n","stdout_sha256":"80f2bb229260f7d797c445dfde090e98a616a384a81de5827faf42cb60c0213e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Certification","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Certification.Bridge' does not depend on any axioms\n'LexLeanTarget.Certification.Certificate' does not depend on any axioms\n'LexLeanTarget.Certification.Certified' does not depend on any axioms\n'LexLeanTarget.Certification.Established' does not depend on any axioms\n'LexLeanTarget.Certification.Fact' does not depend on any axioms\n'LexLeanTarget.Certification.Obligation' does not depend on any axioms\n'LexLeanTarget.Certification.Premise' does not depend on any axioms\n'LexLeanTarget.Certification.Refusal' does not depend on any axioms\n'LexLeanTarget.Certification.Route' does not depend on any axioms\n'LexLeanTarget.Certification.Schema' does not depend on any axioms\n'LexLeanTarget.Certification.Verdict' does not depend on any axioms\n'LexLeanTarget.Certification.allBelow' does not depend on any axioms\n'LexLeanTarget.Certification.allLists' does not depend on any axioms\n'LexLeanTarget.Certification.allLong' does not depend on any axioms\n'LexLeanTarget.Certification.allShorter' does not depend on any axioms\n'LexLeanTarget.Certification.argumentStatus' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.armIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.armsIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.ascending' does not depend on any axioms\n'LexLeanTarget.Certification.bridgePosition' does not depend on any axioms\n'LexLeanTarget.Certification.certificateReductionsPreserve' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.cheaperObservation' does not depend on any axioms\n'LexLeanTarget.Certification.check' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.claimShape' does not depend on any axioms\n'LexLeanTarget.Certification.eligible' does not depend on any axioms\n'LexLeanTarget.Certification.establishedFrom' does not depend on any axioms\n'LexLeanTarget.Certification.exprIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.exprsIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.factAt' does not depend on any axioms\n'LexLeanTarget.Certification.factRows' does not depend on any axioms\n'LexLeanTarget.Certification.factsOf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.firstSmaller' does not depend on any axioms\n'LexLeanTarget.Certification.frontierPosition' does not depend on any axioms\n'LexLeanTarget.Certification.frontierVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.improves' does not depend on any axioms\n'LexLeanTarget.Certification.isList' does not depend on any axioms\n'LexLeanTarget.Certification.isLong' does not depend on any axioms\n'LexLeanTarget.Certification.isNormal' does not depend on any axioms\n'LexLeanTarget.Certification.isShorter' does not depend on any axioms\n'LexLeanTarget.Certification.keepsObservation' does not depend on any axioms\n'LexLeanTarget.Certification.lowerPosition' does not depend on any axioms\n'LexLeanTarget.Certification.lowerVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.natAt' does not depend on any axioms\n'LexLeanTarget.Certification.normalityVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.pairRelation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.pickFrom' does not depend on any axioms\n'LexLeanTarget.Certification.plansIsolated' does not depend on any axioms\n'LexLeanTarget.Certification.positionOf' does not depend on any axioms\n'LexLeanTarget.Certification.premiseFact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.reductionVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.reductionsPreserve' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.representationVerdict' does not depend on any axioms\n'LexLeanTarget.Certification.rewrite' does not depend on any axioms\n'LexLeanTarget.Certification.rowsOfMembers' does not depend on any axioms\n'LexLeanTarget.Certification.sameObjective' does not depend on any axioms\n'LexLeanTarget.Certification.sameObservations' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.sameObservationsAt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.sameScope' does not depend on any axioms\n'LexLeanTarget.Certification.scanBridge' does not depend on any axioms\n'LexLeanTarget.Certification.scanFrontier' does not depend on any axioms\n'LexLeanTarget.Certification.scanLower' does not depend on any axioms\n'LexLeanTarget.Certification.scanReduction' does not depend on any axioms\n'LexLeanTarget.Certification.selectorAt' does not depend on any axioms\n'LexLeanTarget.Certification.sizesOf' does not depend on any axioms\n'LexLeanTarget.Certification.staticCharge' does not depend on any axioms\n'LexLeanTarget.Certification.staticSize' does not depend on any axioms\n'LexLeanTarget.Certification.strictlyCheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.strictlyCheaperAt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Certification.valueAt' does not depend on any axioms\n","stdout_sha256":"80f2bb229260f7d797c445dfde090e98a616a384a81de5827faf42cb60c0213e","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.process.json similarity index 97% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.process.json index b7355b99e..f12456bb5 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Gnaf","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Gnaf.Action' does not depend on any axioms\n'LexLeanTarget.Gnaf.ActionKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.Answer' does not depend on any axioms\n'LexLeanTarget.Gnaf.Boundary' does not depend on any axioms\n'LexLeanTarget.Gnaf.Capacity' does not depend on any axioms\n'LexLeanTarget.Gnaf.Carrier' does not depend on any axioms\n'LexLeanTarget.Gnaf.Charge' does not depend on any axioms\n'LexLeanTarget.Gnaf.ClaimClass' does not depend on any axioms\n'LexLeanTarget.Gnaf.Completeness' does not depend on any axioms\n'LexLeanTarget.Gnaf.Grammar' does not depend on any axioms\n'LexLeanTarget.Gnaf.Machine' does not depend on any axioms\n'LexLeanTarget.Gnaf.Objective' does not depend on any axioms\n'LexLeanTarget.Gnaf.OperandSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.Plan' does not depend on any axioms\n'LexLeanTarget.Gnaf.Prepared' does not depend on any axioms\n'LexLeanTarget.Gnaf.Rejection' does not depend on any axioms\n'LexLeanTarget.Gnaf.Request' does not depend on any axioms\n'LexLeanTarget.Gnaf.Scope' does not depend on any axioms\n'LexLeanTarget.Gnaf.Selector' does not depend on any axioms\n'LexLeanTarget.Gnaf.Status' does not depend on any axioms\n'LexLeanTarget.Gnaf.addNew' does not depend on any axioms\n'LexLeanTarget.Gnaf.admittedRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.allIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.andFalse' does not depend on any axioms\n'LexLeanTarget.Gnaf.andOverOr' does not depend on any axioms\n'LexLeanTarget.Gnaf.answer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.anyBy' does not depend on any axioms\n'LexLeanTarget.Gnaf.anyUnresolved' does not depend on any axioms\n'LexLeanTarget.Gnaf.appendAll' does not depend on any axioms\n'LexLeanTarget.Gnaf.argmin' does not depend on any axioms\n'LexLeanTarget.Gnaf.armCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.armSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.armsCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.armsSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.arrivals' does not depend on any axioms\n'LexLeanTarget.Gnaf.attaining' does not depend on any axioms\n'LexLeanTarget.Gnaf.attains' does not depend on any axioms\n'LexLeanTarget.Gnaf.beqNext' does not depend on any axioms\n'LexLeanTarget.Gnaf.bltNext' does not depend on any axioms\n'LexLeanTarget.Gnaf.bltSucc' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.calleesOf' does not depend on any axioms\n'LexLeanTarget.Gnaf.certifies' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.certifiesArgmin' does not depend on any axioms\n'LexLeanTarget.Gnaf.certifiesFrontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.chargeBeyond' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkAllDeclared' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkClaim' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkDeclared' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkDistinct' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkKindsAccounted' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPerformed' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPlanPreparation' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPrepared' does not depend on any axioms\n'LexLeanTarget.Gnaf.closeOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.componentwiseMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.compositions' does not depend on any axioms\n'LexLeanTarget.Gnaf.countKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchInFixed' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInOver' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInSmalls' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInThresholds' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchSmalls' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchThresholds' does not depend on any axioms\n'LexLeanTarget.Gnaf.dominatedIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.dominates' does not depend on any axioms\n'LexLeanTarget.Gnaf.entryBody' does not depend on any axioms\n'LexLeanTarget.Gnaf.environmentRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.evaluate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.expand' does not depend on any axioms\n'LexLeanTarget.Gnaf.expandComplete' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.exprCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprsCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprsSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.extendAll' does not depend on any axioms\n'LexLeanTarget.Gnaf.extendWalk' does not depend on any axioms\n'LexLeanTarget.Gnaf.fairExpectation' does not depend on any axioms\n'LexLeanTarget.Gnaf.falseAnd' does not depend on any axioms\n'LexLeanTarget.Gnaf.falseOr' does not depend on any axioms\n'LexLeanTarget.Gnaf.findAction' does not depend on any axioms\n'LexLeanTarget.Gnaf.fixedInDispatch' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInFixed' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInOver' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInSmalls' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.frontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.frontierFrom' does not depend on any axioms\n'LexLeanTarget.Gnaf.functionAt' does not depend on any axioms\n'LexLeanTarget.Gnaf.hiddenBitCost' does not depend on any axioms\n'LexLeanTarget.Gnaf.kindIndex' does not depend on any axioms\n'LexLeanTarget.Gnaf.minimaAttained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.minimumFrom' does not depend on any axioms\n'LexLeanTarget.Gnaf.natIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.natInAppend' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.natInRange' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.natSame' does not depend on any axioms\n'LexLeanTarget.Gnaf.normalize' does not depend on any axioms\n'LexLeanTarget.Gnaf.orAssociative' does not depend on any axioms\n'LexLeanTarget.Gnaf.orFalse' does not depend on any axioms\n'LexLeanTarget.Gnaf.orUnderAnd' does not depend on any axioms\n'LexLeanTarget.Gnaf.performed' does not depend on any axioms\n'LexLeanTarget.Gnaf.planAt' does not depend on any axioms\n'LexLeanTarget.Gnaf.planCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.planFunctions' does not depend on any axioms\n'LexLeanTarget.Gnaf.pointwiseMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.preparation' does not depend on any axioms\n'LexLeanTarget.Gnaf.preparedFor' does not depend on any axioms\n'LexLeanTarget.Gnaf.range' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachable' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachableCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachableSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.realize' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej14ComponentwiseMinima' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej14MinimaUnattained' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej29FrontierOmission' does not depend on any axioms\n'LexLeanTarget.Gnaf.rewriteOnce' does not depend on any axioms\n'LexLeanTarget.Gnaf.sameIdsBy' does not depend on any axioms\n'LexLeanTarget.Gnaf.sameKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.scalarMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.scalarRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorInAppend' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.status' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statusOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statusesOf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.uniformRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.unitCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.universeOf' does not depend on any axioms\n'LexLeanTarget.Gnaf.validate' does not depend on any axioms\n'LexLeanTarget.Gnaf.valueEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.valuesEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01CertificateHolds' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01CertificateInvalidated' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01Extension' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01Optimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec02Frontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04GlobalMinimumIsC' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04NormalFormIsB' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04NormalFormRefused' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17EnvelopeAtOne' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17EnvelopeAtZero' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17FairExpectationAtOne' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17FairExpectationAtZero' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17PointwiseValueRefused' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17UniformWorstCase' does not depend on any axioms\n'LexLeanTarget.Gnaf.vectorEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.weaklyBelow' does not depend on any axioms\n'LexLeanTarget.Gnaf.wellFormed' does not depend on any axioms\n'LexLeanTarget.Gnaf.worstCase' does not depend on any axioms\n","stdout_sha256":"1331df9e3d4bee88e89d70ef6b406f01870c0b8da40a372fd990d013ddc52447","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Gnaf","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Gnaf.Action' does not depend on any axioms\n'LexLeanTarget.Gnaf.ActionKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.Answer' does not depend on any axioms\n'LexLeanTarget.Gnaf.Boundary' does not depend on any axioms\n'LexLeanTarget.Gnaf.Capacity' does not depend on any axioms\n'LexLeanTarget.Gnaf.Carrier' does not depend on any axioms\n'LexLeanTarget.Gnaf.Charge' does not depend on any axioms\n'LexLeanTarget.Gnaf.ClaimClass' does not depend on any axioms\n'LexLeanTarget.Gnaf.Completeness' does not depend on any axioms\n'LexLeanTarget.Gnaf.Grammar' does not depend on any axioms\n'LexLeanTarget.Gnaf.Machine' does not depend on any axioms\n'LexLeanTarget.Gnaf.Objective' does not depend on any axioms\n'LexLeanTarget.Gnaf.OperandSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.Plan' does not depend on any axioms\n'LexLeanTarget.Gnaf.Prepared' does not depend on any axioms\n'LexLeanTarget.Gnaf.Rejection' does not depend on any axioms\n'LexLeanTarget.Gnaf.Request' does not depend on any axioms\n'LexLeanTarget.Gnaf.Scope' does not depend on any axioms\n'LexLeanTarget.Gnaf.Selector' does not depend on any axioms\n'LexLeanTarget.Gnaf.Status' does not depend on any axioms\n'LexLeanTarget.Gnaf.addNew' does not depend on any axioms\n'LexLeanTarget.Gnaf.admittedRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.allIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.andFalse' does not depend on any axioms\n'LexLeanTarget.Gnaf.andOverOr' does not depend on any axioms\n'LexLeanTarget.Gnaf.answer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.anyBy' does not depend on any axioms\n'LexLeanTarget.Gnaf.anyUnresolved' does not depend on any axioms\n'LexLeanTarget.Gnaf.appendAll' does not depend on any axioms\n'LexLeanTarget.Gnaf.argmin' does not depend on any axioms\n'LexLeanTarget.Gnaf.armCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.armSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.armsCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.armsSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.arrivals' does not depend on any axioms\n'LexLeanTarget.Gnaf.attaining' does not depend on any axioms\n'LexLeanTarget.Gnaf.attains' does not depend on any axioms\n'LexLeanTarget.Gnaf.beqNext' does not depend on any axioms\n'LexLeanTarget.Gnaf.bltNext' does not depend on any axioms\n'LexLeanTarget.Gnaf.bltSucc' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.calleesOf' does not depend on any axioms\n'LexLeanTarget.Gnaf.certifies' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.certifiesArgmin' does not depend on any axioms\n'LexLeanTarget.Gnaf.certifiesFrontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.chargeBeyond' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkAllDeclared' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkClaim' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkDeclared' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkDistinct' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkKindsAccounted' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPerformed' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPlanPreparation' does not depend on any axioms\n'LexLeanTarget.Gnaf.checkPrepared' does not depend on any axioms\n'LexLeanTarget.Gnaf.closeOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.componentwiseMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.compositions' does not depend on any axioms\n'LexLeanTarget.Gnaf.countKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchInFixed' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInOver' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInSmalls' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchInThresholds' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.dispatchOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchSmalls' does not depend on any axioms\n'LexLeanTarget.Gnaf.dispatchThresholds' does not depend on any axioms\n'LexLeanTarget.Gnaf.dominatedIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.dominates' does not depend on any axioms\n'LexLeanTarget.Gnaf.entryBody' does not depend on any axioms\n'LexLeanTarget.Gnaf.environmentRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.evaluate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.expand' does not depend on any axioms\n'LexLeanTarget.Gnaf.expandComplete' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.exprCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprsCallees' does not depend on any axioms\n'LexLeanTarget.Gnaf.exprsSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.extendAll' does not depend on any axioms\n'LexLeanTarget.Gnaf.extendWalk' does not depend on any axioms\n'LexLeanTarget.Gnaf.fairExpectation' does not depend on any axioms\n'LexLeanTarget.Gnaf.falseAnd' does not depend on any axioms\n'LexLeanTarget.Gnaf.falseOr' does not depend on any axioms\n'LexLeanTarget.Gnaf.findAction' does not depend on any axioms\n'LexLeanTarget.Gnaf.fixedInDispatch' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInFixed' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInOver' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedInSmalls' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.fixedOver' does not depend on any axioms\n'LexLeanTarget.Gnaf.frontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.frontierFrom' does not depend on any axioms\n'LexLeanTarget.Gnaf.functionAt' does not depend on any axioms\n'LexLeanTarget.Gnaf.hiddenBitCost' does not depend on any axioms\n'LexLeanTarget.Gnaf.kindIndex' does not depend on any axioms\n'LexLeanTarget.Gnaf.minimaAttained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.minimumFrom' does not depend on any axioms\n'LexLeanTarget.Gnaf.natIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.natInAppend' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.natInRange' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.natSame' does not depend on any axioms\n'LexLeanTarget.Gnaf.normalize' does not depend on any axioms\n'LexLeanTarget.Gnaf.orAssociative' does not depend on any axioms\n'LexLeanTarget.Gnaf.orFalse' does not depend on any axioms\n'LexLeanTarget.Gnaf.orUnderAnd' does not depend on any axioms\n'LexLeanTarget.Gnaf.performed' does not depend on any axioms\n'LexLeanTarget.Gnaf.planAt' does not depend on any axioms\n'LexLeanTarget.Gnaf.planCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.planFunctions' does not depend on any axioms\n'LexLeanTarget.Gnaf.pointwiseMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.preparation' does not depend on any axioms\n'LexLeanTarget.Gnaf.preparedFor' does not depend on any axioms\n'LexLeanTarget.Gnaf.range' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachable' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachableCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.reachableSize' does not depend on any axioms\n'LexLeanTarget.Gnaf.realize' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej14ComponentwiseMinima' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej14MinimaUnattained' does not depend on any axioms\n'LexLeanTarget.Gnaf.rej29FrontierOmission' does not depend on any axioms\n'LexLeanTarget.Gnaf.rewriteOnce' does not depend on any axioms\n'LexLeanTarget.Gnaf.sameIdsBy' does not depend on any axioms\n'LexLeanTarget.Gnaf.sameKind' does not depend on any axioms\n'LexLeanTarget.Gnaf.scalarMinimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.scalarRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorIn' does not depend on any axioms\n'LexLeanTarget.Gnaf.selectorInAppend' depends on axioms: [propext]\n'LexLeanTarget.Gnaf.status' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statusOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.statusesOf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.Gnaf.uniformRows' does not depend on any axioms\n'LexLeanTarget.Gnaf.unitCharge' does not depend on any axioms\n'LexLeanTarget.Gnaf.universeOf' does not depend on any axioms\n'LexLeanTarget.Gnaf.validate' does not depend on any axioms\n'LexLeanTarget.Gnaf.valueEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.valuesEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01CertificateHolds' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01CertificateInvalidated' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01Extension' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec01Optimum' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec02Frontier' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04GlobalMinimumIsC' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04NormalFormIsB' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec04NormalFormRefused' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17EnvelopeAtOne' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17EnvelopeAtZero' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17FairExpectationAtOne' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17FairExpectationAtZero' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17PointwiseValueRefused' does not depend on any axioms\n'LexLeanTarget.Gnaf.vec17UniformWorstCase' does not depend on any axioms\n'LexLeanTarget.Gnaf.vectorEq' does not depend on any axioms\n'LexLeanTarget.Gnaf.weaklyBelow' does not depend on any axioms\n'LexLeanTarget.Gnaf.wellFormed' does not depend on any axioms\n'LexLeanTarget.Gnaf.worstCase' does not depend on any axioms\n","stdout_sha256":"1331df9e3d4bee88e89d70ef6b406f01870c0b8da40a372fd990d013ddc52447","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.process.json similarity index 99% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.process.json index b9dcfacb7..3f09edaea 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafCertificates","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GnafCertificates.argminOverSystemsPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair2x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair2x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeAttainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeAttainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeMissingCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeMissingVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeNotMinimalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeNotMinimalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeOutOfRangeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeOutOfRangeVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeReducedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeReducedPreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeReducedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnattainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnattainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnprovenVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeViolatedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeViolatedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.claimMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.claimMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierDominatedMemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierDominatedMemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberAtCountCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberAtCountVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberOmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberOmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberUnprovenVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMembersUnorderedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMembersUnorderedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierNonmemberUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierNonmemberUnprovenVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierParetoOptimalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierParetoOptimalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierPremiseWeakenedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierPremiseWeakenedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierTieCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierTieDroppedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierTieDroppedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierTieVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierUnresolvedMemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierUnresolvedMemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierUnresolvedNonmemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierUnresolvedNonmemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierVec02Certificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierVec02Verdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x1Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x1Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair2x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair2x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair1x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair1x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminCompleteCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminCompleteVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminOverSystemsCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminOverSystemsVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminTieCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminTieVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerAtCountCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerAtCountVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerBoundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerBoundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerOutOfRangeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerOutOfRangeVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainersUnorderedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainersUnorderedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbDivergingPlanCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbDivergingPlanVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedAdmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedAdmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedAtLengthCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedAtLengthVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExtraPremiseCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExtraPremiseVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbInfeasibleAttainerCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbInfeasibleAttainerVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbNoAttainerCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbNoAttainerVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbOptimumTieMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbOptimumTieMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbOverUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbOverUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPaysInadmissiblePrefixCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPaysInadmissiblePrefixVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPositionOutOfDomainCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPositionOutOfDomainVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPositionsRepeatedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPositionsRepeatedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPremiseOmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPremiseOmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPremiseWeakenedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPremiseWeakenedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPreparationChargedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPreparationChargedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbTieBoundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbTieBoundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbTieDroppedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbTieDroppedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnattainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnattainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUndercutCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUndercutVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnresolvedMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnresolvedMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnresolvedUnboundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnresolvedUnboundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalClaimedGlobalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalClaimedGlobalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalNotGlobalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalNotGlobalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalityImprovableCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalityImprovableVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalityOptimumCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalityOptimumVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.objectiveMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.objectiveMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIncompleteCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionIncompletePreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIncompleteVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIneligibleCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionIneligiblePreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIneligibleVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionMixedDomainCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionMixedDomainPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionMixedDomainVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionOverUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionOverUnresolvedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionParetoCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionParetoVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionShortListsCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionShortListsPreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionShortListsVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgePreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgeVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCachedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.requestRejectedCachedPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCachedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.requestRejectedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reusedEnlargedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reusedEnlargedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.routeIncompatibleCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.routeIncompatibleVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.routeLowerBoundParetoCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.routeLowerBoundParetoVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.scopeMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.scopeMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair0x0Cheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair0x0Keeps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair1x0Cheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair1x0Keeps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.verifierMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.verifierMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"71d56f58daf3ebbc941b59ce5953be0e2d87a70a3d394ccbec6873c2bfc11058","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafCertificates","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GnafCertificates.argminOverSystemsPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair2x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.argminOverSystemsPair2x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeAttainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeAttainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeMissingCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeMissingVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeNotMinimalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeNotMinimalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeOutOfRangeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeOutOfRangeVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeReducedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeReducedPreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeReducedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnattainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnattainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnprovenVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.bridgeViolatedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.bridgeViolatedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.claimMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.claimMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierDominatedMemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierDominatedMemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberAtCountCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberAtCountVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberOmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberOmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMemberUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMemberUnprovenVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierMembersUnorderedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierMembersUnorderedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierNonmemberUnprovenCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierNonmemberUnprovenVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierParetoOptimalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierParetoOptimalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierPremiseWeakenedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierPremiseWeakenedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierTieCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierTieDroppedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierTieDroppedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierTieVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierUnresolvedMemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierUnresolvedMemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierUnresolvedNonmemberCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierUnresolvedNonmemberVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.frontierVec02Certificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.frontierVec02Verdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x1Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair0x1Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair2x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.inadmissiblePlanExcludedPair2x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair0x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair0x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair1x0Cheaper' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.internalBestOnShortListsPair1x0Keeps' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminCompleteCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminCompleteVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminOverSystemsCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminOverSystemsVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbArgminTieCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbArgminTieVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerAtCountCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerAtCountVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerBoundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerBoundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainerOutOfRangeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainerOutOfRangeVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbAttainersUnorderedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbAttainersUnorderedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbDivergingPlanCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbDivergingPlanVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedAdmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedAdmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedAtLengthCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedAtLengthVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExcludedUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExcludedUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbExtraPremiseCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbExtraPremiseVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbInfeasibleAttainerCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbInfeasibleAttainerVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbNoAttainerCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbNoAttainerVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbOptimumTieMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbOptimumTieMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbOverUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbOverUnresolvedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPaysInadmissiblePrefixCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPaysInadmissiblePrefixVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPositionOutOfDomainCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPositionOutOfDomainVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPositionsRepeatedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPositionsRepeatedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPremiseOmittedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPremiseOmittedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPremiseWeakenedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPremiseWeakenedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbPreparationChargedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbPreparationChargedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbTieBoundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbTieBoundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbTieDroppedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbTieDroppedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnattainedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnattainedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUndercutCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUndercutVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnresolvedMeasuredCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnresolvedMeasuredVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.lbUnresolvedUnboundedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.lbUnresolvedUnboundedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalClaimedGlobalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalClaimedGlobalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalNotGlobalCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalNotGlobalVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalityImprovableCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalityImprovableVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.normalityOptimumCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.normalityOptimumVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.objectiveMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.objectiveMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionCollapseDistinctVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIncompleteCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionIncompletePreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIncompleteVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIneligibleCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionIneligiblePreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionIneligibleVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionMixedDomainCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionMixedDomainPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionMixedDomainVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionOverUnresolvedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionOverUnresolvedVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionParetoCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionParetoVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionShortListsCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionShortListsPreserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionShortListsVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionSmallAtThresholdVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgeCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgePreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.reductionThresholdEdgeVerdict' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCachedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.requestRejectedCachedPreserves' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCachedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.requestRejectedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.requestRejectedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.reusedEnlargedCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.reusedEnlargedVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.routeIncompatibleCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.routeIncompatibleVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.routeLowerBoundParetoCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.routeLowerBoundParetoVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.scopeMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.scopeMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair0x0Cheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair0x0Keeps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair1x0Cheaper' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.thresholdEdgePair1x0Keeps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafCertificates.verifierMismatchCertificate' does not depend on any axioms\n'LexLeanTarget.GnafCertificates.verifierMismatchVerdict' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"71d56f58daf3ebbc941b59ce5953be0e2d87a70a3d394ccbec6873c2bfc11058","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.process.json similarity index 99% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.process.json index 86aa09834..d98062f6e 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GnafFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GnafFixtures.argminCompleteAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminCompleteRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminCompleteStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminCompleteUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminOverSystemsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminOverSystemsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminOverSystemsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminOverSystemsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.bridgeStraightLineAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.bridgeStraightLineRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.bridgeStraightLineStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.bridgeStraightLineUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierIncomparableAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierIncomparableRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierIncomparableStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierIncomparableUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.infeasibleUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.infeasibleUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.infeasibleUniverseStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.infeasibleUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationChargedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationChargedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationChargedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationChargedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonPlanAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonPlanRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonPlanStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonPlanUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonStateAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonStateStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningArgminAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningArgminRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningArgminStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningArgminUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningFrontierAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningFrontierRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningFrontierStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningFrontierUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCommunicationAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCommunicationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCommunicationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreeObservationAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectFreeObservationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreeObservationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRandomnessAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRandomnessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRandomnessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSchedulingAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectSchedulingRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSchedulingUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.thresholdEdgeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.thresholdEdgeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.thresholdEdgeStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.thresholdEdgeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeCertified' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeMinimaUnattained' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits0' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec08EnlargedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec08EnlargedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec08EnlargedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec08EnlargedUniverse' does not depend on any axioms\n","stdout_sha256":"e81a8012148d7879e88bf0122728eaf3bc463a9dc405d7de812313e48575f9fc","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GnafFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GnafFixtures.argminCompleteAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminCompleteRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminCompleteStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminCompleteUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminOverSystemsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminOverSystemsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminOverSystemsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminOverSystemsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.argminTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.argminTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.boundOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.bridgeStraightLineAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.bridgeStraightLineRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.bridgeStraightLineStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.bridgeStraightLineUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierIncomparableAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierIncomparableRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierIncomparableStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierIncomparableUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierParetoOptimalUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.frontierTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.frontierTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.inadmissiblePlanExcludedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.infeasibleUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.infeasibleUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.infeasibleUniverseStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.infeasibleUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnLongListsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.internalBestOnShortListsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumOverUnresolvedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumTieAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumTieRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.optimumTieStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.optimumTieUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationChargedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationChargedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationChargedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationChargedUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonPlanAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonPlanRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonPlanStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonPlanUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonStateAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.preparationCommonStateStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.preparationCommonStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningArgminAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningArgminRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningArgminStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningArgminUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningFrontierAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningFrontierRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.reasoningFrontierStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.reasoningFrontierUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectBeyondCapacityUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCachedUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCalculusProgramScopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCommunicationAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectCommunicationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectCommunicationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectConstantCostFallbackUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDiscoveredUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectDuplicateActionUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectEmptyDomainUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreeObservationAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectFreeObservationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreeObservationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectFreePreprocessingCompleteBoundaryUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInstanceOptimalClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectInternalPlanUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectMissingCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectOptimizerDefinedUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectProfileDefinedComparisonClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRandomnessAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRandomnessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRandomnessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningDiscoveredUniverseUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectReasoningFreeSearchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRestrictedUniverseAliasUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectRustProgramScopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectScalarClaimPartialOrderUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSchedulingAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectSchedulingRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSchedulingUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectSelfReferentialCompletenessUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStepChargedAdviceUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectStrayPreparedArtifactUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedDispatchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnaccountedPlanPreparationUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnboundPreparedStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredExecutionUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUndeclaredRetainedStateUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnitCostOperandsUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectUnsupportedClaimUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectVectorClaimTotalOrderUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostDispatchUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingAnswer' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.rejectZeroCostPreprocessingUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.thresholdEdgeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.thresholdEdgeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.thresholdEdgeStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.thresholdEdgeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.unknownCostIncompleteUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeCertified' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeMinimaUnattained' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits0' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeOmits2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec02ParetoEnvelopeUniverse' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec08EnlargedAnswer' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec08EnlargedRequest' does not depend on any axioms\n'LexLeanTarget.GnafFixtures.vec08EnlargedStatuses' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GnafFixtures.vec08EnlargedUniverse' does not depend on any axioms\n","stdout_sha256":"e81a8012148d7879e88bf0122728eaf3bc463a9dc405d7de812313e48575f9fc","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.process.json similarity index 96% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.process.json index c31e27913..21b3ff002 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.GradeOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GradeOracle.Grade' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Ledger' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Run' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Step' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.accept' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.account' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.answer' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.attempts' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude_accept' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.extract' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.fire' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.firings_bounded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.follow' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.next' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_preserves_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.observe' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay_fire' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.run' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.run_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.run_state' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.run_trace' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.saturate' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturate_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.select' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.start' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_count' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_fired' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_none' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_some' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_trace' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.verdict' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Graded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Related' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Scale.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_correct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_pending' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.gradedCheck' does not depend on any axioms\n'LexLeanTarget.GradeOracle.graded_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.related_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.related_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"41e26d5b11d5016c3ee787bc19434a0752cf8d9139e8c67bcd737479a87622e5","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.GradeOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.GradeOracle.Grade' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Ledger' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Run' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.Step' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.accept' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.account' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.answer' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.attempts' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude_accept' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.extract' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.fire' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.firings_bounded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.follow' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.next' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_preserves_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.observe' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay_fire' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.run' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.run_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.run_state' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.run_trace' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.saturate' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturate_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Grade.select' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.start' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_count' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_fired' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_none' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_some' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.step_trace' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.verdict' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Grade.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.Graded' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Related' does not depend on any axioms\n'LexLeanTarget.GradeOracle.Scale.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_correct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.grade_pending' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.GradeOracle.gradedCheck' does not depend on any axioms\n'LexLeanTarget.GradeOracle.graded_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.related_admitted' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.GradeOracle.related_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"41e26d5b11d5016c3ee787bc19434a0752cf8d9139e8c67bcd737479a87622e5","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.process.json similarity index 50% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.process.json index a648772e0..1a2dca6d9 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Main.emptyProgram' does not depend on any axioms\n","stdout_sha256":"7d2326f4d7e78d1f284ea2efd07b36431427f867a86f0aed74877f3834844c2d","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.Main","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.Main.emptyProgram' does not depend on any axioms\n","stdout_sha256":"7d2326f4d7e78d1f284ea2efd07b36431427f867a86f0aed74877f3834844c2d","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.process.json similarity index 99% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.process.json index a6ea9e728..9f889d39d 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.PlannerOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.PlannerOracle.Anywhere.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.EmptyB.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.EmptyB.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.EmptyB.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.EmptyB.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.FillA.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Fits' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Held' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Inside.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Measured.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Measures' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Moves' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.explained' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.explained' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.verdict_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Pour.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Pour.candidates' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pouring.preserves' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Whole' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Within' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.empty_jugs_fit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.emptyb_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.filla_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.fits_kept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.held_initial' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.held_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.measuresCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.measures_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.plan_fit_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.plan_held_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.plan_whole_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.pour_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.wholeCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.whole_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.withinCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.within_sound' depends on axioms: [propext]\n","stdout_sha256":"0758e97b7a8f57ecef82cca97e2d440e8ff64d83b29d17bef960473b67dec2b7","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.PlannerOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.PlannerOracle.Anywhere.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.EmptyB.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.EmptyB.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.EmptyB.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.EmptyB.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.FillA.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.FillA.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Fits' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Held' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Inside.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Measured.sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Measures' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Moves' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.explained' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Plan.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Plan.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Plan.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFit.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFit.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFit.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.follow_relation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitR.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitR.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitR.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.EmptyB.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.EmptyB.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.FillA.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.FillA.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Ledger' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Node' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.collect' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Pour.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Search' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.Step' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.accept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.accept_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.answer' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.attempts' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.expansions_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.explained' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.extend' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.extract' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.failure' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.follow' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.fresh' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.fresh_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.frontier_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.iterations_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.observe' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay_fire' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.run' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.searchStep' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_count' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_expanded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_ok' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_peak' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_step' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.search_verify_growth' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.start' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.successors' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.successors_ok' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.PlanFitU.verdict' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.PlanFitU.verdict_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.PlanFitU.verifications_bounded' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.Pour.apply' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.Pour.candidates' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.conclusion' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pour.guard' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Pouring.preserves' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Whole' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.Within' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.empty_jugs_fit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.emptyb_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.filla_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.fits_kept' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.held_initial' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.held_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.measuresCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.measures_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.plan_fit_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.plan_held_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.plan_whole_correct' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.PlannerOracle.pour_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.PlannerOracle.wholeCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.whole_sound' depends on axioms: [propext]\n'LexLeanTarget.PlannerOracle.withinCheck' does not depend on any axioms\n'LexLeanTarget.PlannerOracle.within_sound' depends on axioms: [propext]\n","stdout_sha256":"0758e97b7a8f57ecef82cca97e2d440e8ff64d83b29d17bef960473b67dec2b7","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.process.json similarity index 97% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.process.json index 7f0cac551..9d18cda8d 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ReasoningFixtures.encodeDoseSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeDoseStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeFailure' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodePlanSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodePlanStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeScreenSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeScreenStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeTriageStep' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeTriageSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedAgrees' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedAgrees' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"1de37e5613059ad2366b5f16de757528c552aa5af91db58ab847229eab7edaef","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ReasoningFixtures.encodeDoseSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeDoseStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeFailure' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodePlanSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodePlanStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeScreenSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeScreenStepsOne' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeTriageStep' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.encodeTriageSteps' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose120Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningDose60Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafGoalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafPriorityRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGnafSweepRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGradeShockRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningGradeWellRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningPlan2Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningPlan5Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedAgrees' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningReviewExhaustedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedAgrees' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningReviewRejectedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen0Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen100Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningScreen60Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Program' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningSpend2Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageShockRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedOutcome' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageTracedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellProgram' does not depend on any axioms\n'LexLeanTarget.ReasoningFixtures.reasoningTriageWellRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"1de37e5613059ad2366b5f16de757528c552aa5af91db58ab847229eab7edaef","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.process.json similarity index 98% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.process.json index 94d766e78..55ea2e8b8 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ReasoningOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ReasoningOracle.Chart' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Consistent' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Discharged' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Escalate.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Escalate.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Febrile' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Fever.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Fever.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Findings.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Hypotensive' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Indicated' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Justified' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Leukocytosis.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Outpatient.sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Pending' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Recommendation.complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Recommendation.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Ledger' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.account' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.answer' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.attempts' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude_accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.explained' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.extract' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.firings_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.follow' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.next' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.observe' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay_fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.run_state' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.run_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.saturate' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.select' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.start' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_count' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_fired' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_none' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_some' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.verdict' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Sepsis.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sepsis.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sepsis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sepsis.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sepsis.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Shock.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Shock.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sirs.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sirs.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachycardia.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachypnea.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypneic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Ledger' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.account' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.answer' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.attempts' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude_accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.extract' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.firings_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.follow' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.next' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.observe' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay_fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.run_state' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.run_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.saturate' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.select' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.start' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_count' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_fired' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_none' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_some' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.verdict' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Vitals' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Warranted' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.admitted_consistent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.admitted_pending' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.consistent_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.dischargeCheck' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.discharge_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.escalate_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.escalate_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.fever_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.fever_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.feverish' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.hypotensive' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.leukocytic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.leukocytosis_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.leukocytosis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.recommendationCheck' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.recommendation_complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.recommendation_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sepsis_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sepsis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.shock_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.shock_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sirs_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sirs_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardia_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardia_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.tachypnea_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachypnea_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachypneic' does not depend on any axioms\n","stdout_sha256":"6379b45e287b8ba78784669ac39cab6f41ad650597c513813a6a806f7cd9a16a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ReasoningOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ReasoningOracle.Chart' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Consistent' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Discharged' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Escalate.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Escalate.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Escalate.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Febrile' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Fever.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Fever.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Fever.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Findings.preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Hypotensive' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Indicated' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Justified' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Leukocytosis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Leukocytosis.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Leukocytosis.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Outpatient.sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Pending' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Recommendation.complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Recommendation.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Ledger' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.Step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.account' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.answer' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.attempts' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude_accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.conclude_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.explained' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Review.extract' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.firings_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.follow' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.next' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.observe' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay_fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.run_state' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.run_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.saturate' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Review.select' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.start' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_count' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_fired' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_none' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_some' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.step_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.verdict' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Review.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.Sepsis.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sepsis.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sepsis.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sepsis.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sepsis.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Shock.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Shock.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Shock.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sirs.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Sirs.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Sirs.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachycardia.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachycardia.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardia.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachycardic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachypnea.apply_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Tachypnea.conclusion' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypnea.guard' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Tachypneic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Ledger' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.Step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.accept_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.account' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.answer' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.attempts' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude_accept' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.conclude_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.explained' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.extract' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.fire_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.fire_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.firings_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.follow' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.follow_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.next' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.next_preserves' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.next_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.next_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.observe' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay_fire' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.replay_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.run' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.run_state' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.run_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.saturate' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.saturate_derivation' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.saturate_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.saturates' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Triage.select' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.start' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_count' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_fired' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_none' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_some' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.step_trace' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.verdict' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Triage.verdict_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.Vitals' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.Warranted' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.admitted_consistent' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.admitted_pending' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.consistent_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.dischargeCheck' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.discharge_sound' depends on axioms: [propext]\n'LexLeanTarget.ReasoningOracle.escalate_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.escalate_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.fever_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.fever_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.feverish' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.hypotensive' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.leukocytic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.leukocytosis_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.leukocytosis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.recommendationCheck' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.recommendation_complete' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.recommendation_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sepsis_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sepsis_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.shock_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.shock_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sirs_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.sirs_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardia_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardia_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachycardic' does not depend on any axioms\n'LexLeanTarget.ReasoningOracle.tachypnea_progress' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachypnea_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.ReasoningOracle.tachypneic' does not depend on any axioms\n","stdout_sha256":"6379b45e287b8ba78784669ac39cab6f41ad650597c513813a6a806f7cd9a16a","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.process.json similarity index 94% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.process.json index cd26748ae..9b8cccdf3 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.RustSemantics.ROutcome' does not depend on any axioms\n'LexLeanTarget.RustSemantics.ROutcomes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns' does not depend on any axioms\n'LexLeanTarget.RustSemantics.constructValue' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.fallibleType' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findFunction' does not depend on any axioms\n'LexLeanTarget.RustSemantics.finished' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.invoke' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.isBytes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemShifts' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.lookup' does not depend on any axioms\n'LexLeanTarget.RustSemantics.patternsOf' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned' does not depend on any axioms\n'LexLeanTarget.RustSemantics.runExport' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.runItem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.sameIdent' does not depend on any axioms\n'LexLeanTarget.RustSemantics.widened' does not depend on any axioms\n","stdout_sha256":"c4a74f7df92c28739cb1b581e499298ce1763d48d3d86b5e835853a86cf5a339","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.RustSemantics.ROutcome' does not depend on any axioms\n'LexLeanTarget.RustSemantics.ROutcomes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns' does not depend on any axioms\n'LexLeanTarget.RustSemantics.constructValue' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.fallibleType' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findFunction' does not depend on any axioms\n'LexLeanTarget.RustSemantics.finished' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.invoke' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.isBytes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemShifts' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.lookup' does not depend on any axioms\n'LexLeanTarget.RustSemantics.patternsOf' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned' does not depend on any axioms\n'LexLeanTarget.RustSemantics.runExport' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.runItem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.sameIdent' does not depend on any axioms\n'LexLeanTarget.RustSemantics.widened' does not depend on any axioms\n","stdout_sha256":"c4a74f7df92c28739cb1b581e499298ce1763d48d3d86b5e835853a86cf5a339","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.process.json similarity index 88% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.process.json index bf025274f..08c2f700c 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.RustSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.RustSyntax.Arm' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Block' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Callee' does not depend on any axioms\n'LexLeanTarget.RustSyntax.CaptureRead' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Crate' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Ctor' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Dispatch' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Expr' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Ident' does not depend on any axioms\n'LexLeanTarget.RustSyntax.IdentKind' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Item' does not depend on any axioms\n'LexLeanTarget.RustSyntax.ItemDef' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Let' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Lit' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Parameter' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Pat' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Profile' does not depend on any axioms\n'LexLeanTarget.RustSyntax.RustType' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Variant' does not depend on any axioms\n","stdout_sha256":"340586ca755a53bbd0e772cc6bb0bd43c7dc6e45a64449a50df424ff1ad72629","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.RustSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.RustSyntax.Arm' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Block' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Callee' does not depend on any axioms\n'LexLeanTarget.RustSyntax.CaptureRead' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Crate' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Ctor' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Dispatch' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Expr' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Ident' does not depend on any axioms\n'LexLeanTarget.RustSyntax.IdentKind' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Item' does not depend on any axioms\n'LexLeanTarget.RustSyntax.ItemDef' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Let' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Lit' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Parameter' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Pat' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Profile' does not depend on any axioms\n'LexLeanTarget.RustSyntax.RustType' does not depend on any axioms\n'LexLeanTarget.RustSyntax.Variant' does not depend on any axioms\n","stdout_sha256":"340586ca755a53bbd0e772cc6bb0bd43c7dc6e45a64449a50df424ff1ad72629","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.process.json similarity index 97% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.process.json index 8fc5c47bd..54f86a2c6 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.ScreeningOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ScreeningOracle.Dose' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Ledger' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Trial' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.answer' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.candidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.explained' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.failure' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.run' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.run_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.try' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.try_count' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.try_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.verdict' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.verifications_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verify' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verify_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.DoseCandidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.DoseContract.postcondition_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.DoseModel' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.apply' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.apply_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Propose.candidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.conclusion' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.guard' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Proposed' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Safe' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.SafeDose.sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Ledger' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Node' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.collect' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.successors' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.successors_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Search' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.accept' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.answer' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.attempts' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.derivation' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.expansions_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.explained' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.extend' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.extract' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.failure' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.fire' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.fire_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.follow' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.frontier_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.observe' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay_fire' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.run' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.searchStep' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_count' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_expanded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_peak' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_verify_growth' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.start' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.successors' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.successors_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.verdict' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.verifications_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Short' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.propose_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.safeCheck' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.safe_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.shortCheck' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.short_sound' depends on axioms: [propext]\n","stdout_sha256":"9d44b4b2ace8f5e69c8889eeabedaab7479c25761828af32df261812b28b9066","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.ScreeningOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.ScreeningOracle.Dose' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Ledger' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.Trial' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.answer' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.candidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.explained' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.failure' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.run' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.run_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.try' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.try_count' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.try_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.verdict' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Dose.verifications_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verify' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Dose.verify_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.DoseCandidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.DoseContract.postcondition_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.DoseModel' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.apply' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.apply_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Propose.candidates' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.conclusion' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Propose.guard' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Proposed' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Safe' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.SafeDose.sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Ledger' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Node' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.collect' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.successors' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Propose.successors_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Search' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.Step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.accept' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.accept_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.answer' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.attempts' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.derivation' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.expansions_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.explained' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.extend' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.extract' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.failure' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.fire' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.fire_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.follow' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.frontier_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.iterations_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.observe' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay_fire' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.replay_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.run' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.searchStep' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_count' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_expanded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_peak' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_step' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.search_verify_growth' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.start' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.successors' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.successors_ok' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.verdict' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Screen.verdict_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.Screen.verifications_bounded' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.Short' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.propose_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.safeCheck' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.safe_sound' depends on axioms: [propext]\n'LexLeanTarget.ScreeningOracle.shortCheck' does not depend on any axioms\n'LexLeanTarget.ScreeningOracle.short_sound' depends on axioms: [propext]\n","stdout_sha256":"9d44b4b2ace8f5e69c8889eeabedaab7479c25761828af32df261812b28b9066","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.process.json similarity index 99% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.process.json index 21f20c2f5..7825aca89 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetFixtures.adtEvaluationOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.adtEvaluationProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.adtEvaluationRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bindingAndShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bindingAndShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.bindingAndShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleanShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleanShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.booleanShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleansOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleansProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.booleansRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.boxedFieldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.boxedFieldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.boxedFieldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteCompareProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteCompareRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteOrderProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteOrderRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteSlicesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteSlicesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteSlicesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bytesAndTextOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bytesAndTextProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.bytesAndTextRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureCapturesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureCapturesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureCapturesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureDispatchOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureDispatchProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureDispatchRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureInlineOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureInlineProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureInlineRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureRecursiveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureRecursiveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureRecursiveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureUninhabitedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureUninhabitedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureUninhabitedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureValueOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureValueProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureValueRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closuresOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closuresProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closuresRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.convertOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.convertProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.convertRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalOverflowProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalOverflowRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalOverflowWideProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalOverflowWideRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.equalityOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.equalityProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.equalityRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fallibleConditionValueOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fallibleConditionValueProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fallibleConditionValueRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsSignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsSignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedBitsSignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedWideOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedWideProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedWideRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI16Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI32Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI64Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU16Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU32Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU64Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.functionShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.functionShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.functionShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableInnerRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphSuccessorsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphTopologicalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intArithmeticOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intArithmeticProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intArithmeticRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowMulOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowMulProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowMulRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowNegOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowNegProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowNegRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowQuotOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowQuotProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowQuotRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowSubOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowSubProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowSubRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateUntilRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listAppendLongOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listAppendLongProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listAppendLongRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.literalsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.literalsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.literalsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapContainsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertLastRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertReplaceAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertReplaceOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertReplaceProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertReplaceRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapKeysRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapLookupAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapLookupRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapRemoveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapValuesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.matchShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.matchShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.matchShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natArithmeticOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natArithmeticProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natArithmeticRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowAddOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowAddProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowAddRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowMulOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowMulProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowMulRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowNestedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowNestedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowNestedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowSuccOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowSuccProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowSuccRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.orderingOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.orderingProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.orderingRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.pairAndListMatchOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.pairAndListMatchProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.pairAndListMatchRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.recordFieldsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.recordFieldsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.recordFieldsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setContainsAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setContainsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setDifferenceRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertBoolRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertInt8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertIntRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertNatRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertProductRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertStringRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setIntersectionRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setRemoveAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setRemoveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setUnionRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.splitAndJoinProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.splitAndJoinRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.stringEscapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.stringEscapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.stringEscapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToExhaustedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToExhaustedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.sumToExhaustedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.sumToRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitClosuresOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitClosuresProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.unitClosuresRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitValuesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitValuesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.unitValuesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.wideShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.wideShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.wideShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"9028f03268ae25228c0a1c64afc3998515828206dcf201c38e280caf05fb7ca0","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetFixtures","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetFixtures.adtEvaluationOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.adtEvaluationProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.adtEvaluationRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bindingAndShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bindingAndShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.bindingAndShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleanShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleanShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.booleanShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleansOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.booleansProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.booleansRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.boxedFieldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.boxedFieldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.boxedFieldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteCompareProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteCompareRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteOrderProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteOrderRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteSlicesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.byteSlicesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.byteSlicesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bytesAndTextOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.bytesAndTextProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.bytesAndTextRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureCapturesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureCapturesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureCapturesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureDispatchOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureDispatchProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureDispatchRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureInlineOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureInlineProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureInlineRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureRecursiveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureRecursiveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureRecursiveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureUninhabitedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureUninhabitedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureUninhabitedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureValueOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closureValueProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closureValueRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closuresOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.closuresProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.closuresRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.convertOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.convertProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.convertRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalOverflowProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalOverflowRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalOverflowWideProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalOverflowWideRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.decimalProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.decimalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.equalityOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.equalityProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.equalityRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fallibleConditionValueOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fallibleConditionValueProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fallibleConditionValueRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsSignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsSignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedBitsSignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedBitsUnsignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedNarrowRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedSignedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedWideOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedCheckedWideProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedCheckedWideRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalI8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalI8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedDecimalU8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedDecimalU8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI16Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI32Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI64Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthI8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthI8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU16Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU16Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU16Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU32Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU32Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU32Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU64Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU64Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU64Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.fixedWidthU8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.fixedWidthU8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.functionShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.functionShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.functionShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableInnerProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableInnerRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphReachableProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphReachableRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphSuccessorsAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphSuccessorsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphSuccessorsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphTopologicalCycleRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.graphTopologicalProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.graphTopologicalRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intArithmeticOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intArithmeticProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intArithmeticRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowMulOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowMulProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowMulRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowNegOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowNegProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowNegRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowQuotOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowQuotProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowQuotRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowSubOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.intOverflowSubProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.intOverflowSubRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateUntilBoundedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.iterateUntilProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.iterateUntilRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listAppendLongOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listAppendLongProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listAppendLongRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.listsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.listsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.literalsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.literalsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.literalsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapContainsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapContainsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertLastProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertLastRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertReplaceAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertReplaceOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertReplaceProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapInsertReplaceRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapInsertRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapKeysProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapKeysRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapLookupAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapLookupProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapLookupRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapRemoveAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapRemoveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapRemoveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.mapValuesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.mapValuesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.matchShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.matchShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.matchShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natArithmeticOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natArithmeticProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natArithmeticRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowAddOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowAddProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowAddRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowMulOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowMulProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowMulRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowNestedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowNestedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowNestedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowSuccOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.natOverflowSuccProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.natOverflowSuccRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.orderingOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.orderingProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.orderingRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.pairAndListMatchOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.pairAndListMatchProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.pairAndListMatchRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.recordFieldsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.recordFieldsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.recordFieldsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setContainsAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setContainsProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setContainsRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setDifferenceProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setDifferenceRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setFoldProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setFoldRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertBoolProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertBoolRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Agrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Outcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertInt8Program' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertInt8Run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertIntProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertIntRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertNatProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertNatRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertProductProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertProductRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setInsertStringProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setInsertStringRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setIntersectionProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setIntersectionRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAbsentProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setRemoveAbsentRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setRemoveProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setRemoveRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionAgrees' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.setUnionProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.setUnionRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.splitAndJoinProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.splitAndJoinRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.stringEscapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.stringEscapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.stringEscapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToExhaustedOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToExhaustedProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.sumToExhaustedRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.sumToProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.sumToRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitClosuresOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitClosuresProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.unitClosuresRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitValuesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.unitValuesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.unitValuesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.wideShapesOutcome' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetFixtures.wideShapesProgram' does not depend on any axioms\n'LexLeanTarget.TargetFixtures.wideShapesRun' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"9028f03268ae25228c0a1c64afc3998515828206dcf201c38e280caf05fb7ca0","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.process.json similarity index 80% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.process.json index 8c8e797a0..b9aee03c1 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetOracle.encodeAdjacency' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeBools' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeI8s' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeInts' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeNatStrings' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeNats' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeStrings' does not depend on any axioms\n","stdout_sha256":"e5d09f1ed61a07fda3dba02d424da6b01bceef18c4e1e3c70b41a8c133503ccd","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetOracle","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetOracle.encodeAdjacency' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeBools' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeI8s' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeInts' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeNatStrings' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeNats' does not depend on any axioms\n'LexLeanTarget.TargetOracle.encodeStrings' does not depend on any axioms\n","stdout_sha256":"e5d09f1ed61a07fda3dba02d424da6b01bceef18c4e1e3c70b41a8c133503ccd","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.process.json similarity index 94% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.process.json index b90600c23..538fa3721 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetSemantics.Outcome' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.Outcomes' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.addSteps' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.construct' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.depth' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.fromOrdering' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.fromStrings' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.lookup' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.natResult' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.orderI16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderInt' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderNat' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderOf' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.sameOrder' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.toStrings' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.weight' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.weights' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"5db7059cbd2e67dd7cdac827d671c436156acb744114ba6a068eca77cfb130ca","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetSemantics.Outcome' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.Outcomes' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.addSteps' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.construct' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.depth' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.fromOrdering' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.fromStrings' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.lookup' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.natResult' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.orderI16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderI8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderInt' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderNat' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderOf' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderU8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.sameOrder' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.toStrings' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.weight' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.weights' depends on axioms: [propext, Classical.choice, Quot.sound]\n","stdout_sha256":"5db7059cbd2e67dd7cdac827d671c436156acb744114ba6a068eca77cfb130ca","tool":"lean"} diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.lean b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.lean similarity index 100% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.lean rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.lean diff --git a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.process.json b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.process.json similarity index 83% rename from compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.process.json rename to compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.process.json index ab7a4e08d..d7c2c67ab 100644 --- a/compiler/expected/verify/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.process.json +++ b/compiler/expected/verify/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ac8f5fdecd4eefbea9d5648c31c7d3f79.LexLeanTarget.TargetSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetSyntax.Adt' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Arm' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Expr' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Function' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Order' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Prim' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Program' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Shape' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Ty' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Value' does not depend on any axioms\n","stdout_sha256":"81b555d6535a4ba91c825f93f1d0da80257f7eb8f83fff55f85f7e2fe759deba","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ae36982ff9545254b9a90d88b07a1ff91.LexLeanTarget.TargetSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanTarget.TargetSyntax.Adt' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Arm' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Expr' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Function' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Order' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Prim' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Program' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Shape' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Ty' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.Value' does not depend on any axioms\n","stdout_sha256":"81b555d6535a4ba91c825f93f1d0da80257f7eb8f83fff55f85f7e2fe759deba","tool":"lean"} diff --git a/compiler/expected/verify/probe/LexLeanProbe.Pc8f5fdecd4eefbea9d5648c31c7d3f79.lean b/compiler/expected/verify/probe/LexLeanProbe.Pe36982ff9545254b9a90d88b07a1ff91.lean similarity index 100% rename from compiler/expected/verify/probe/LexLeanProbe.Pc8f5fdecd4eefbea9d5648c31c7d3f79.lean rename to compiler/expected/verify/probe/LexLeanProbe.Pe36982ff9545254b9a90d88b07a1ff91.lean diff --git a/compiler/expected/verify/probe/process.json b/compiler/expected/verify/probe/process.json index b2d7ab39c..9d5621d79 100644 --- a/compiler/expected/verify/probe/process.json +++ b/compiler/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pc8f5fdecd4eefbea9d5648c31c7d3f79.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pc8f5fdecd4eefbea9d5648c31c7d3f79","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pe36982ff9545254b9a90d88b07a1ff91.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pe36982ff9545254b9a90d88b07a1ff91","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.lean b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.lean similarity index 100% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.lean rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.lean diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.process.json similarity index 97% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.process.json rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.process.json index 1c132e5a7..6e9a75190 100644 --- a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.process.json +++ b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanCollections.Key' does not depend on any axioms\n'LexLeanCollections.Key.casesOn' does not depend on any axioms\n'LexLeanCollections.Key.compare' does not depend on any axioms\n'LexLeanCollections.Key.ctorIdx' does not depend on any axioms\n'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms\n'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusion' does not depend on any axioms\n'LexLeanCollections.Key.noConfusionType' does not depend on any axioms\n'LexLeanCollections.Key.recOn' does not depend on any axioms\n'LexLeanCollections.compareCodes' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._f' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext]\n'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.match_4' does not depend on any axioms\n'LexLeanCollections.containsElement' does not depend on any axioms\n'LexLeanCollections.containsElement._f' does not depend on any axioms\n'LexLeanCollections.containsElement._sunfold' does not depend on any axioms\n'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.graphNodes' does not depend on any axioms\n'LexLeanCollections.graphReachable' depends on axioms: [propext]\n'LexLeanCollections.graphSuccessors' does not depend on any axioms\n'LexLeanCollections.graphTopological' does not depend on any axioms\n'LexLeanCollections.insertElement' does not depend on any axioms\n'LexLeanCollections.insertElement._f' does not depend on any axioms\n'LexLeanCollections.insertElement._sunfold' does not depend on any axioms\n'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertElement.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry' does not depend on any axioms\n'LexLeanCollections.insertEntry._f' does not depend on any axioms\n'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.match_3' does not depend on any axioms\n'LexLeanCollections.instKeyBool' depends on axioms: [propext]\n'LexLeanCollections.instKeyInt' does not depend on any axioms\n'LexLeanCollections.instKeyInt16' does not depend on any axioms\n'LexLeanCollections.instKeyInt32' does not depend on any axioms\n'LexLeanCollections.instKeyInt64' does not depend on any axioms\n'LexLeanCollections.instKeyInt8' does not depend on any axioms\n'LexLeanCollections.instKeyNat' does not depend on any axioms\n'LexLeanCollections.instKeyProd' depends on axioms: [propext]\n'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.instKeyUInt16' does not depend on any axioms\n'LexLeanCollections.instKeyUInt32' does not depend on any axioms\n'LexLeanCollections.instKeyUInt64' does not depend on any axioms\n'LexLeanCollections.instKeyUInt8' does not depend on any axioms\n'LexLeanCollections.iterate' does not depend on any axioms\n'LexLeanCollections.iterate._f' does not depend on any axioms\n'LexLeanCollections.iterate._sunfold' does not depend on any axioms\n'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterate.match_1' does not depend on any axioms\n'LexLeanCollections.iterateUntil' does not depend on any axioms\n'LexLeanCollections.iterateUntil._f' does not depend on any axioms\n'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms\n'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms\n'LexLeanCollections.lessThan' depends on axioms: [propext]\n'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.lessThan.match_1' depends on axioms: [propext]\n'LexLeanCollections.listFold' does not depend on any axioms\n'LexLeanCollections.lookupEntry' does not depend on any axioms\n'LexLeanCollections.lookupEntry._f' does not depend on any axioms\n'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.mapContains' does not depend on any axioms\n'LexLeanCollections.mapEntries' does not depend on any axioms\n'LexLeanCollections.mapFold' does not depend on any axioms\n'LexLeanCollections.mapInsert' does not depend on any axioms\n'LexLeanCollections.mapKeys' does not depend on any axioms\n'LexLeanCollections.mapLookup' does not depend on any axioms\n'LexLeanCollections.mapRemove' does not depend on any axioms\n'LexLeanCollections.mapSize' does not depend on any axioms\n'LexLeanCollections.mapValues' does not depend on any axioms\n'LexLeanCollections.reachableFrom' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._f' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext]\n'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms\n'LexLeanCollections.removeElement' does not depend on any axioms\n'LexLeanCollections.removeElement._f' does not depend on any axioms\n'LexLeanCollections.removeElement._sunfold' does not depend on any axioms\n'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.removeEntry' does not depend on any axioms\n'LexLeanCollections.removeEntry._f' does not depend on any axioms\n'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms\n'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms\n'LexLeanCollections.setContains' does not depend on any axioms\n'LexLeanCollections.setDifference' does not depend on any axioms\n'LexLeanCollections.setElements' does not depend on any axioms\n'LexLeanCollections.setFold' does not depend on any axioms\n'LexLeanCollections.setInsert' does not depend on any axioms\n'LexLeanCollections.setIntersection' does not depend on any axioms\n'LexLeanCollections.setRemove' does not depend on any axioms\n'LexLeanCollections.setSize' does not depend on any axioms\n'LexLeanCollections.setUnion' does not depend on any axioms\n'LexLeanCollections.topological' does not depend on any axioms\n'LexLeanCollections.topological._f' does not depend on any axioms\n'LexLeanCollections.topological._sunfold' does not depend on any axioms\n'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms\n","stdout_sha256":"b75acc0e99e23684c3cc876eacbfc93f47161cfee8a7440df17fa45f321c8c6a","tool":"lean"} diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.lean b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.lean similarity index 100% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanRuntime.Portable.lean rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.lean diff --git a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.process.json similarity index 98% rename from bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.process.json rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.process.json index 4f2ed57dd..a74bd20a7 100644 --- a/bootstrap/expected/verify/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.process.json +++ b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Aadb40bbfc73b1dc6b7a95dab0c348a27.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanRuntime.Appendable' does not depend on any axioms\n'LexLeanRuntime.Appendable.append' does not depend on any axioms\n'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Appendable.recOn' does not depend on any axioms\n'LexLeanRuntime.Decimal' does not depend on any axioms\n'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms\n'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Decimal.format' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Decimal.parse' does not depend on any axioms\n'LexLeanRuntime.Decimal.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms\n'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms\n'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms\n'LexLeanRuntime.Fixed.maximum' does not depend on any axioms\n'LexLeanRuntime.Fixed.minimum' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Fixed.recOn' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms\n'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms\n'LexLeanRuntime.Indexable' does not depend on any axioms\n'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Indexable.index' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Indexable.recOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable' does not depend on any axioms\n'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Lengthable.length' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Quotient.isZero' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Quotient.quotient' does not depend on any axioms\n'LexLeanRuntime.Quotient.recOn' does not depend on any axioms\n'LexLeanRuntime.Quotient.remainder' does not depend on any axioms\n'LexLeanRuntime.Sliceable' does not depend on any axioms\n'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms\n'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms\n'LexLeanRuntime.Sliceable.slice' does not depend on any axioms\n'LexLeanRuntime.ToMathInt' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms\n'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms\n'LexLeanRuntime.append' does not depend on any axioms\n'LexLeanRuntime.bitAnd' does not depend on any axioms\n'LexLeanRuntime.bitNot' does not depend on any axioms\n'LexLeanRuntime.bitOr' does not depend on any axioms\n'LexLeanRuntime.bitXor' does not depend on any axioms\n'LexLeanRuntime.checkedAdd' does not depend on any axioms\n'LexLeanRuntime.checkedAddInt64' does not depend on any axioms\n'LexLeanRuntime.checkedConvert' does not depend on any axioms\n'LexLeanRuntime.checkedFromInt' does not depend on any axioms\n'LexLeanRuntime.checkedMultiply' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms\n'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.checkedNegate' does not depend on any axioms\n'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms\n'LexLeanRuntime.checkedQuotient' does not depend on any axioms\n'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms\n'LexLeanRuntime.checkedSubtract' does not depend on any axioms\n'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms\n'LexLeanRuntime.compareBytes' depends on axioms: [propext]\n'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.equal' does not depend on any axioms\n'LexLeanRuntime.formatDecimal' does not depend on any axioms\n'LexLeanRuntime.index' does not depend on any axioms\n'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms\n'LexLeanRuntime.instAppendableList' does not depend on any axioms\n'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms\n'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound]\n'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms\n'LexLeanRuntime.instIndexableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms\n'LexLeanRuntime.instLengthableList' does not depend on any axioms\n'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.instQuotientInt' does not depend on any axioms\n'LexLeanRuntime.instQuotientNat' does not depend on any axioms\n'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms\n'LexLeanRuntime.instSliceableList' does not depend on any axioms\n'LexLeanRuntime.instToMathIntInt' does not depend on any axioms\n'LexLeanRuntime.join' depends on axioms: [propext]\n'LexLeanRuntime.length' does not depend on any axioms\n'LexLeanRuntime.listIndex' does not depend on any axioms\n'LexLeanRuntime.listIndex._f' does not depend on any axioms\n'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms\n'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.listIndex.match_1' does not depend on any axioms\n'LexLeanRuntime.magnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiply' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms\n'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms\n'LexLeanRuntime.negate' does not depend on any axioms\n'LexLeanRuntime.parseDecimal' does not depend on any axioms\n'LexLeanRuntime.quotient' does not depend on any axioms\n'LexLeanRuntime.remainder' does not depend on any axioms\n'LexLeanRuntime.shiftLeft' does not depend on any axioms\n'LexLeanRuntime.shiftRight' does not depend on any axioms\n'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms\n'LexLeanRuntime.slice' does not depend on any axioms\n'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.subtract' does not depend on any axioms\n'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.utf8Encode' does not depend on any axioms\n","stdout_sha256":"73fea1d9e9e9f0a2f1363b9f284eeeb9e434430e9fa910260b9526bad864641e","tool":"lean"} diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.lean b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.lean similarity index 100% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.lean rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.lean diff --git a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.process.json similarity index 82% rename from stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.process.json rename to stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.process.json index 46ebd1828..851b2bc77 100644 --- a/stdlib/expected/verify/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.process.json +++ b/stdlib/expected/verify/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/audit/LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.A5bfc6ad2db2940a1b7735f1309be47dc.LexLeanStd.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanStd.Text.byteAt' does not depend on any axioms\n'LexLeanStd.Text.chomp' does not depend on any axioms\n'LexLeanStd.Text.endsWith' does not depend on any axioms\n'LexLeanStd.Text.find' does not depend on any axioms\n'LexLeanStd.Text.isSpace' does not depend on any axioms\n'LexLeanStd.Text.joinWith' does not depend on any axioms\n'LexLeanStd.Text.lineStep' does not depend on any axioms\n'LexLeanStd.Text.lines' does not depend on any axioms\n'LexLeanStd.Text.matchAt' does not depend on any axioms\n'LexLeanStd.Text.reverse' does not depend on any axioms\n'LexLeanStd.Text.sliceOr' does not depend on any axioms\n'LexLeanStd.Text.spaceAt' does not depend on any axioms\n'LexLeanStd.Text.splitOn' does not depend on any axioms\n'LexLeanStd.Text.splitStep' does not depend on any axioms\n'LexLeanStd.Text.startsWith' does not depend on any axioms\n'LexLeanStd.Text.trim' does not depend on any axioms\n'LexLeanStd.Text.trimEnd' does not depend on any axioms\n'LexLeanStd.Text.trimStart' does not depend on any axioms\n","stdout_sha256":"7d0d170dc8609025273db5f55bfa751ad62c100aa8693fd9fbafa3d1782b3751","tool":"lean"} +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Af6fd2434413f885eb97b3577e92c0706.LexLeanStd.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanStd.Text.byteAt' does not depend on any axioms\n'LexLeanStd.Text.chomp' does not depend on any axioms\n'LexLeanStd.Text.endsWith' does not depend on any axioms\n'LexLeanStd.Text.find' does not depend on any axioms\n'LexLeanStd.Text.isSpace' does not depend on any axioms\n'LexLeanStd.Text.joinWith' does not depend on any axioms\n'LexLeanStd.Text.lineStep' does not depend on any axioms\n'LexLeanStd.Text.lines' does not depend on any axioms\n'LexLeanStd.Text.matchAt' does not depend on any axioms\n'LexLeanStd.Text.reverse' does not depend on any axioms\n'LexLeanStd.Text.sliceOr' does not depend on any axioms\n'LexLeanStd.Text.spaceAt' does not depend on any axioms\n'LexLeanStd.Text.splitOn' does not depend on any axioms\n'LexLeanStd.Text.splitStep' does not depend on any axioms\n'LexLeanStd.Text.startsWith' does not depend on any axioms\n'LexLeanStd.Text.trim' does not depend on any axioms\n'LexLeanStd.Text.trimEnd' does not depend on any axioms\n'LexLeanStd.Text.trimStart' does not depend on any axioms\n","stdout_sha256":"7d0d170dc8609025273db5f55bfa751ad62c100aa8693fd9fbafa3d1782b3751","tool":"lean"} diff --git a/stdlib/expected/verify/extract/LexLeanExtract.X5bfc6ad2db2940a1b7735f1309be47dc.lean b/stdlib/expected/verify/extract/LexLeanExtract.Xf6fd2434413f885eb97b3577e92c0706.lean similarity index 100% rename from stdlib/expected/verify/extract/LexLeanExtract.X5bfc6ad2db2940a1b7735f1309be47dc.lean rename to stdlib/expected/verify/extract/LexLeanExtract.Xf6fd2434413f885eb97b3577e92c0706.lean diff --git a/stdlib/expected/verify/extract/process.json b/stdlib/expected/verify/extract/process.json index 2c03323c0..0daf975ec 100644 --- a/stdlib/expected/verify/extract/process.json +++ b/stdlib/expected/verify/extract/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/extract/LexLeanExtract.X5bfc6ad2db2940a1b7735f1309be47dc.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.X5bfc6ad2db2940a1b7735f1309be47dc","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"LexLeanStd.Text.startsWith\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.trim\",\"LexLeanStd.Text.splitOn\",\"LexLeanStd.Text.lines\",\"LexLeanStd.Text.joinWith\",\"LexLeanStd.Text.find\"],\"constants\":[{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.byteAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"UInt8\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.chomp\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}]}}}}}}}}}}}},\"uses\":[\"Array\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Sub\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.endsWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}]}}}}}}}}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.find\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.88\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.101\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.105\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.120\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.isSpace\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.or\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"12\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.128\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.168\",\"parameters\":[{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"PUnit\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.joinWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.joinWith.match_1\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.112\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}}}]}}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.lineStep\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"UInt8.instOfNat\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.chomp\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.chomp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}}}}}}}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.122\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.chomp\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.lines\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.lineStep\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.lineStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Prod.mk\",\"LexLeanStd.Text.lineStep\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.matchAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.reverse\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}},\"uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.sliceOr\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.spaceAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.isSpace\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.isSpace\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.isSpace\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.splitOn\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Prod\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.splitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.splitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.splitStep\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.splitStep\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}}}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.startsWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"OfNat.ofNat\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}]}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trim\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.trimEnd\",\"LexLeanStd.Text.trimStart\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.trimEnd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.trimStart\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.trimEnd\",\"LexLeanStd.Text.trimStart\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trimEnd\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.spaceAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.spaceAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}}}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.spaceAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trimStart\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.spaceAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.spaceAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}}}}}}}]}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.spaceAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.joinWith.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.sliceOr.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.spaceAt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt8\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"fbd831ab2f1b732386c68cc6e61810df6cc71d4cb8500118007439491f5d6988","tool":"lean"} +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xf6fd2434413f885eb97b3577e92c0706.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xf6fd2434413f885eb97b3577e92c0706","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"{\"spec\":\"lexlean/lcnf-extraction/2\",\"lean\":{\"version\":\"4.32.1\",\"githash\":\"f054605aea4b840552cca2e725580bffd1e1b704\"},\"roots\":[\"LexLeanStd.Text.startsWith\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.trim\",\"LexLeanStd.Text.splitOn\",\"LexLeanStd.Text.lines\",\"LexLeanStd.Text.joinWith\",\"LexLeanStd.Text.find\"],\"constants\":[{\"name\":\"LexLeanCollections.iterateUntil\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Nat.brecOn\",\"LexLeanCollections.iterateUntil._f\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}}}},\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.68\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]}},\"borrow\":false},{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.70\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.79\",\"parameters\":[{\"id\":\"_uniq.76\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.78\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.79\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.121\",\"parameters\":[{\"id\":\"_uniq.91\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.92\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.101\",\"parameters\":[{\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.92\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.100\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.104\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.68\"},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.105\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.68\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.92\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.115\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.102\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.116\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.117\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.118\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.119\"}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]}}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.121\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Nat\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"discriminant\":\"_uniq.69\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Nat.zero\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.128\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.128\"}}},{\"kind\":\"constructor\",\"constructor\":\"Nat.succ\",\"parameters\":[{\"id\":\"_uniq.129\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.130\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.122\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.129\"},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.130\"}}}]}}}}}},\"uses\":[\"Bool\",\"Nat\",\"Option\",\"PUnit\",\"Prod\",\"Bool.false\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"Nat.succ\",\"Nat.zero\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.listFold\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"List\",\"List.foldl\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}}},\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}}},\"borrow\":false},{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"borrow\":false},{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},\"value\":{\"kind\":\"const\",\"name\":\"List.foldl\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}},{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}},\"uses\":[\"List\",\"List.foldl\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Appendable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"bvar\",\"index\":2}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Indexable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":2,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Indexable.mk\",\"parameters\":2,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2}]}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":2},{\"kind\":\"bvar\",\"index\":1}]}}}}}]}},{\"name\":\"LexLeanRuntime.Lengthable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.Sliceable\",\"kind\":\"inductive\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":{\"parameters\":1,\"indices\":0,\"recursive\":false,\"constructors\":[{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"parameters\":1,\"fields\":1,\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":0},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1}]}}}}]}},{\"name\":\"LexLeanRuntime.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.append\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false},{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Appendable\",\"index\":0,\"value\":\"_uniq.30\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}},\"uses\":[\"LexLeanRuntime.Appendable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.equal\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"BEq\",\"BEq.beq\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"borrow\":false},{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"BEq\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.25\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.26\"}}}},\"uses\":[\"BEq\",\"Bool\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.index\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":1},{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":3}]}}}}}},\"parameters\":[{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"borrow\":false},{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Indexable\",\"index\":0,\"value\":\"_uniq.26\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.34\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.35\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Indexable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.append\",\"LexLeanRuntime.Appendable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.fastAppend\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.2\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.2\"}}}},\"uses\":[\"ByteArray\",\"ByteArray.fastAppend\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.Appendable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Array\",\"ByteArray\",\"Nat\",\"UInt8\",\"instLTNat\",\"Array.instGetElem?NatLtSize\",\"Array.size\",\"ByteArray.data\",\"GetElem?.getElem?\",\"LT.lt\",\"LexLeanRuntime.Indexable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.7\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.9\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"GetElem?\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Array.instGetElem?NatLtSize\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"GetElem?\",\"index\":1,\"value\":\"_uniq.9\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.data\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.7\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}}},\"uses\":[\"Array\",\"ByteArray\",\"GetElem?\",\"Nat\",\"Option\",\"UInt8\",\"Array.instGetElem?NatLtSize\",\"ByteArray.data\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.Indexable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.1\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"borrowed\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.5\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.1\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.5\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"ByteArray.size\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"instLENat\",\"ite\",\"ByteArray.extract\",\"ByteArray.size\",\"HAdd.hAdd\",\"LE.le\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"parameters\":[],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.10\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.22\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.23\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.size\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.decLe\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"},{\"kind\":\"fvar\",\"id\":\"_uniq.25\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.26\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.28\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.extract\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.10\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"uses\":[\"Add\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"Option\",\"instAddNat\",\"instHAdd\",\"ByteArray.extract\",\"ByteArray.size\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Sliceable\",\"Nat.decLe\",\"Option.none\",\"Option.some\",\"LexLeanRuntime.Sliceable.mk\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Lengthable.length\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"borrow\":false},{\"id\":\"_uniq.17\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Lengthable\",\"index\":0,\"value\":\"_uniq.16\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.18\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.17\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.19\"}}}},\"uses\":[\"Nat\",\"LexLeanRuntime.Lengthable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.Sliceable.slice\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":4}]}}}}}},\"parameters\":[{\"id\":\"_uniq.23\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.24\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"borrow\":false},{\"id\":\"_uniq.25\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"borrow\":false},{\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.23\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]}}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"LexLeanRuntime.Sliceable\",\"index\":0,\"value\":\"_uniq.24\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.29\"}}}},\"uses\":[\"Nat\",\"Option\",\"LexLeanRuntime.Sliceable\"]},\"inductive\":null},{\"name\":\"LexLeanRuntime.subtract\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Sub\",\"instHSub\",\"HSub.hSub\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"sort\",\"level\":\"1\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"bvar\",\"index\":0}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":1},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"bvar\",\"index\":2},\"codomain\":{\"kind\":\"bvar\",\"index\":3}}}}},\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"sort\",\"level\":\"1\"},\"borrow\":false},{\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"borrow\":false},{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HSub\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instHSub\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"codomain\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HSub\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}}},\"uses\":[\"HSub\",\"Sub\",\"instHSub\"]},\"inductive\":null},{\"name\":\"LexLeanCollections.iterate.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Nat\",\"instOfNatNat\",\"Nat.casesOn\",\"Nat.succ\",\"OfNat.ofNat\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil._f\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":true,\"kernel_uses\":[\"Bool\",\"Nat\",\"Option\",\"Prod\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"Bool.true\",\"Nat.below\",\"Nat.succ\",\"OfNat.ofNat\",\"Prod.mk\",\"LexLeanCollections.iterate.match_1\",\"LexLeanCollections.iterateUntil.match_1\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanCollections.iterateUntil.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Collections\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.append\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Appendable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Appendable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.index\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Indexable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Indexable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.length\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Lengthable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Lengthable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.mk\",\"kind\":\"constructor\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"kernel_uses\":[],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanRuntime.Sliceable.slice\",\"kind\":\"definition\",\"module\":\"LexLeanRuntime.Portable\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"LexLeanRuntime.Sliceable\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.byteAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"UInt8\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Indexable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instIndexableByteArrayUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.14\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.index\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.14\"}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"LexLeanRuntime.Indexable\",\"LexLeanRuntime.index\",\"LexLeanRuntime.instIndexableByteArrayUInt8\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.chomp\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"ByteArray.mk\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"OfNat.ofNat\",\"UInt8.instOfNat\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.9\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.19\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.22\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.23\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.23\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.endsWith\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.25\"},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.27\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.28\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"return\",\"id\":\"_uniq.9\"}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.29\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.31\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.34\"},{\"kind\":\"fvar\",\"id\":\"_uniq.9\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.37\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.9\"},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.40\"}}}}}}}}}}}}}]}}}}}}}}}}}},\"uses\":[\"Array\",\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Sub\",\"UInt8\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"ByteArray.mk\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"List.toArray\",\"UInt8.instOfNat\",\"LexLeanStd.Text.endsWith\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.endsWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"Unit\",\"instDecidableEqBool\",\"instSubNat\",\"ite\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.42\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.ble\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.43\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.54\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.55\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.57\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.66\",\"parameters\":[{\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.65\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.66\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.73\",\"parameters\":[{\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.72\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.73\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"},{\"kind\":\"fvar\",\"id\":\"_uniq.43\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.85\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.74\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.67\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.89\"}}}]}}}}}}}}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"Option\",\"PUnit\",\"Sub\",\"instDecidableEqBool\",\"instSubNat\",\"Bool.false\",\"Bool.true\",\"ByteArray.instBEq\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanRuntime.subtract\",\"Nat.ble\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.find\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.matchAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.36\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.38\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.96\",\"parameters\":[{\"id\":\"_uniq.41\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.52\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.53\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.81\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.83\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.84\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.85\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.88\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.80\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.91\"}}}}}}}]}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.94\"}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.100\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.101\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.105\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.108\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.matchAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.120\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.118\"},{\"kind\":\"fvar\",\"id\":\"_uniq.119\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.120\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.122\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.123\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}]}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.matchAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.isSpace\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.or\",\"LexLeanRuntime.equal\",\"OfNat.ofNat\",\"UInt8.instOfNat\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.92\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.75\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.69\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"13\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.71\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.72\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.73\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.74\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.75\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.81\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"12\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.82\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.86\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.76\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.89\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.90\"}}}}]}}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.110\",\"parameters\":[{\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.107\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.108\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.109\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.111\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.119\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.128\",\"parameters\":[{\"id\":\"_uniq.121\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.122\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"9\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.124\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.125\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.123\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.128\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.134\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.135\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.134\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.136\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"32\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.137\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.136\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.138\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.137\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.139\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.135\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.138\"}]},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.162\",\"parameters\":[{\"id\":\"_uniq.144\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.155\",\"parameters\":[{\"id\":\"_uniq.149\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.149\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.150\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.151\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.93\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.150\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.151\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.152\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.153\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.152\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.153\"}}}}]}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.158\",\"parameters\":[{\"id\":\"_uniq.156\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.157\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.111\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.156\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.157\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.161\",\"parameters\":[{\"id\":\"_uniq.159\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.160\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.101\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.159\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.155\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.160\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.144\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.145\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.158\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.145\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.147\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.161\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.147\"}]}}}]}}}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.165\",\"parameters\":[{\"id\":\"_uniq.163\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.164\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.129\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.163\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.164\"}]}}},\"body\":{\"kind\":\"join\",\"declaration\":{\"id\":\"_uniq.168\",\"parameters\":[{\"id\":\"_uniq.166\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.167\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.119\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.166\"}]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.162\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.167\"}]}}},\"body\":{\"kind\":\"cases\",\"type_name\":\"Bool\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.139\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Bool.false\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.140\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.165\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.140\"}]}}},{\"kind\":\"constructor\",\"constructor\":\"Bool.true\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.142\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"jump\",\"target\":\"_uniq.168\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.142\"}]}}}]}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"Decidable\",\"Nat\",\"OfNat\",\"PUnit\",\"UInt8\",\"instBEqOfDecidableEq\",\"instDecidableEqUInt8\",\"Bool.false\",\"Bool.true\",\"LexLeanRuntime.equal\",\"UInt8.instOfNat\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.joinWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.joinWith.match_1\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.55\",\"parameters\":[{\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.54\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.64\",\"parameters\":[{\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.63\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.64\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.112\",\"parameters\":[{\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.88\",\"parameters\":[{\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.87\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.88\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.98\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Appendable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instAppendableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.93\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.append\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.97\"}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.98\",\"arguments\":[]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.79\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.108\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.89\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.107\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.108\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.109\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.99\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.109\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.110\"}}}]}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.113\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.112\"},{\"kind\":\"fvar\",\"id\":\"_uniq.113\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.114\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.116\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.65\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.115\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.116\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.117\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.118\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.117\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.118\"}}}]}}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanCollections.listFold\",\"LexLeanRuntime.Appendable\",\"LexLeanRuntime.append\",\"LexLeanRuntime.instAppendableByteArray\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.lineStep\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"UInt8.instOfNat\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.chomp\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}},\"parameters\":[{\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.49\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.52\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.51\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.106\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.71\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.70\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.72\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"10\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.73\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"UInt8.instOfNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.72\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.74\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.73\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.75\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.71\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.74\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.76\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.75\"},{\"kind\":\"fvar\",\"id\":\"_uniq.76\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.77\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.78\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.79\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.80\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.82\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.82\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.83\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.81\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.84\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.85\"},{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.87\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.88\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.89\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.91\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.93\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.93\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.94\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.92\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.95\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.97\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.53\"},{\"kind\":\"fvar\",\"id\":\"_uniq.98\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.chomp\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.96\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.104\"}}}}}}}}}}}}}}}}}]}}}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.106\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.113\",\"parameters\":[{\"id\":\"_uniq.111\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.112\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.112\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.114\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.113\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.122\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"},{\"kind\":\"fvar\",\"id\":\"_uniq.50\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.122\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.123\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.124\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.114\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.123\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.124\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.125\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.107\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.125\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.126\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"UInt8.instOfNat\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.chomp\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.lines\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Prod\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.lineStep\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.28\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.33\",\"parameters\":[{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.lineStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.32\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.34\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.35\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.33\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.39\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.40\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.44\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"discriminant\":\"_uniq.58\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.59\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.60\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.61\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"},{\"kind\":\"fvar\",\"id\":\"_uniq.29\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}}}}}]}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Nat.blt\",\"Prod.mk\",\"LexLeanStd.Text.lineStep\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.matchAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.64\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.66\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.69\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.70\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.69\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.70\"}}}]}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.reverse\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},\"parameters\":[{\"id\":\"_uniq.8\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.14\",\"parameters\":[{\"id\":\"_uniq.11\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"borrow\":false},{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.13\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.11\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.13\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.listFold\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.14\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.8\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.16\"}}}}},\"uses\":[\"ByteArray\",\"List\",\"LexLeanCollections.listFold\",\"List.cons\",\"List.nil\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.sliceOr\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"ByteArray.mk\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}}},\"parameters\":[{\"id\":\"_uniq.36\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.45\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"return\",\"id\":\"_uniq.44\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.45\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Array\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.toArray\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.51\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.mk\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.53\"}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.54\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.63\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"discriminant\":\"_uniq.64\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.55\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.67\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.68\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.67\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.68\"}}}]}}}}}}}},\"uses\":[\"Array\",\"ByteArray\",\"List\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"ByteArray.mk\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.slice\",\"List.nil\",\"List.toArray\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.spaceAt\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"UInt8\",\"Unit\",\"Bool.false\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.isSpace\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.39\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.isSpace\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.38\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.39\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.46\",\"parameters\":[{\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.45\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.46\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.55\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.57\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.58\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.59\"}}}]}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"PUnit\",\"UInt8\",\"Bool.false\",\"Option.none\",\"Option.some\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.isSpace\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.splitOn\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"Prod\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"OfNat.ofNat\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.splitStep\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}}},\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.22\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.27\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.32\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.splitStep\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.22\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.33\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.33\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.35\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.34\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.36\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.nil\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.37\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.36\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.35\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.32\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.40\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.39\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.41\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.43\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.46\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.42\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.47\"},{\"kind\":\"fvar\",\"id\":\"_uniq.48\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.reverse\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.50\"}}}}}}}}}}}}}}}}}}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"UInt8\",\"instOfNatNat\",\"instSubNat\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"List.cons\",\"List.nil\",\"Prod.mk\",\"LexLeanStd.Text.reverse\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.splitStep\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.splitStep\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"List\",\"Nat\",\"Option\",\"Prod\",\"UInt8\",\"Unit\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"Prod.mk\",\"Prod.snd\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.spaceAt.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}}}},\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.49\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.56\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.59\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":1,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.61\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.109\",\"parameters\":[{\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.77\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]}}},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqUInt8\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.78\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instBEqOfDecidableEq\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.77\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.79\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.78\"},{\"kind\":\"fvar\",\"id\":\"_uniq.66\"},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.80\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.81\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.79\"},{\"kind\":\"fvar\",\"id\":\"_uniq.80\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.81\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.82\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.83\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.84\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.83\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.85\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.84\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.86\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.87\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.86\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.88\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.87\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.89\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.85\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.88\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.90\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.91\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.89\"},{\"kind\":\"fvar\",\"id\":\"_uniq.90\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.92\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.91\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.92\"}}}}}}}}}}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.93\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.94\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.95\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.94\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.96\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.95\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.97\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.98\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.97\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.99\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.98\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.100\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.96\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.99\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.101\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.102\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.101\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.103\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.102\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.104\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"List.cons\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.103\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.105\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.104\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.106\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Prod.mk\",\"levels\":[\"0\",\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.100\"},{\"kind\":\"fvar\",\"id\":\"_uniq.105\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.107\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}},{\"kind\":\"fvar\",\"id\":\"_uniq.106\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.107\"}}}}}}}}}}}}}}}}]}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.110\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.109\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.116\",\"parameters\":[{\"id\":\"_uniq.114\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.115\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.115\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.117\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.116\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.125\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.byteAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.48\"},{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"discriminant\":\"_uniq.125\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.126\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.127\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.117\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.126\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.127\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.128\",\"type\":{\"kind\":\"const\",\"name\":\"UInt8\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.129\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"List\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]}]}]}]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.110\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.128\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.129\"}}}]}}}}}}}}}}}}}},\"uses\":[\"Add\",\"BEq\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"List\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"Prod\",\"Sub\",\"UInt8\",\"instAddNat\",\"instBEqOfDecidableEq\",\"instDecidableEqBool\",\"instDecidableEqUInt8\",\"instHAdd\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.subtract\",\"List.cons\",\"Option.none\",\"Option.some\",\"Prod.mk\",\"Unit.unit\",\"LexLeanStd.Text.byteAt\",\"LexLeanStd.Text.sliceOr\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.startsWith\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Nat\",\"Option\",\"Unit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"OfNat.ofNat\",\"LexLeanStd.Text.sliceOr.match_1\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.40\",\"parameters\":[{\"id\":\"_uniq.37\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.38\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"BEq\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"ByteArray.instBEq\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.39\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.equal\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.38\"},{\"kind\":\"fvar\",\"id\":\"_uniq.37\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.39\"}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.40\",\"arguments\":[]},\"body\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.47\",\"parameters\":[{\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.false\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.46\"}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.48\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"codomain\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.47\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Sliceable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instSliceableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.57\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.59\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.58\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.60\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.slice\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.61\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Option\",\"result_type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"discriminant\":\"_uniq.62\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Option.none\",\"parameters\":[],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"const\",\"name\":\"PUnit\",\"levels\":[\"1\"]},\"value\":{\"kind\":\"const\",\"name\":\"Unit.unit\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.48\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.63\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}},{\"kind\":\"constructor\",\"constructor\":\"Option.some\",\"parameters\":[{\"id\":\"_uniq.65\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.66\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.41\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.65\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.66\"}}}]}}}}}}}}}}}}},\"uses\":[\"BEq\",\"Bool\",\"ByteArray\",\"Nat\",\"OfNat\",\"Option\",\"PUnit\",\"instOfNatNat\",\"Bool.false\",\"ByteArray.instBEq\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.Sliceable\",\"LexLeanRuntime.equal\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.instSliceableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.slice\",\"Option.none\",\"Option.some\",\"Unit.unit\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trim\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Nat\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.trimEnd\",\"LexLeanStd.Text.trimStart\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.12\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"let\",\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.trimEnd\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.16\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.15\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.17\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.trimStart\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.17\",\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.19\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.20\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.16\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.sliceOr\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.12\"},{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.20\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.21\"}}}}}}}}},\"uses\":[\"ByteArray\",\"Nat\",\"Sub\",\"instSubNat\",\"LexLeanRuntime.subtract\",\"LexLeanStd.Text.sliceOr\",\"LexLeanStd.Text.trimEnd\",\"LexLeanStd.Text.trimStart\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trimEnd\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"ite\",\"Bool.true\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.spaceAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},\"parameters\":[{\"id\":\"_uniq.13\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.54\",\"parameters\":[{\"id\":\"_uniq.15\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.24\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.25\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.24\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.26\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.25\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.27\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.26\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.28\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.29\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.27\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.29\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.30\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.31\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.32\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.41\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Sub\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instSubNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.42\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.43\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.42\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.43\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.subtract\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.41\"},{\"kind\":\"fvar\",\"id\":\"_uniq.15\"},{\"kind\":\"fvar\",\"id\":\"_uniq.44\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.46\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.spaceAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.13\"},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.46\"},{\"kind\":\"fvar\",\"id\":\"_uniq.28\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.47\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.49\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.50\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.45\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.51\"}}}]}}}}}}}}}]}}}}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.Lengthable\",\"levels\":[]},\"arguments\":[{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.instLengthableByteArray\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanRuntime.length\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"},{\"kind\":\"fvar\",\"id\":\"_uniq.13\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.57\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"},{\"kind\":\"fvar\",\"id\":\"_uniq.56\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.58\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.57\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.58\"}}}}}}},\"uses\":[\"Bool\",\"ByteArray\",\"Decidable\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"Sub\",\"instDecidableEqBool\",\"instOfNatNat\",\"instSubNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"LexLeanRuntime.Lengthable\",\"LexLeanRuntime.instLengthableByteArray\",\"LexLeanRuntime.length\",\"LexLeanRuntime.subtract\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.spaceAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.trimStart\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Bool\",\"ByteArray\",\"Eq\",\"Nat\",\"Option\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"ite\",\"Bool.true\",\"HAdd.hAdd\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"OfNat.ofNat\",\"Option.none\",\"Option.some\",\"Prod.fst\",\"LexLeanStd.Text.spaceAt\"],\"declaration\":{\"safe\":true,\"level_parameters\":[],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"parameters\":[{\"id\":\"_uniq.18\",\"type\":{\"kind\":\"const\",\"name\":\"ByteArray\",\"levels\":[]},\"borrow\":false},{\"id\":\"_uniq.19\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"value\":{\"kind\":\"code\",\"code\":{\"kind\":\"fun\",\"declaration\":{\"id\":\"_uniq.59\",\"parameters\":[{\"id\":\"_uniq.21\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"borrow\":false}],\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]}},\"value\":{\"kind\":\"let\",\"id\":\"_uniq.30\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Nat.blt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.31\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"Bool.true\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.32\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.30\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.32\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.33\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.34\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.34\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.35\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.44\",\"type\":{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanStd.Text.spaceAt\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.18\"},{\"kind\":\"fvar\",\"id\":\"_uniq.21\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.45\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Decidable\",\"levels\":[]},\"arguments\":[{\"kind\":\"erased\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instDecidableEqBool\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.44\"},{\"kind\":\"fvar\",\"id\":\"_uniq.31\"}]},\"body\":{\"kind\":\"cases\",\"type_name\":\"Decidable\",\"result_type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"discriminant\":\"_uniq.45\",\"alternatives\":[{\"kind\":\"constructor\",\"constructor\":\"Decidable.isFalse\",\"parameters\":[{\"id\":\"_uniq.46\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.47\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.none\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.47\"}}},{\"kind\":\"constructor\",\"constructor\":\"Decidable.isTrue\",\"parameters\":[{\"id\":\"_uniq.48\",\"type\":{\"kind\":\"erased\"},\"borrow\":false}],\"code\":{\"kind\":\"let\",\"id\":\"_uniq.49\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Add\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instAddNat\",\"levels\":[],\"arguments\":[]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.50\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"HAdd\",\"levels\":[\"0\",\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"instHAdd\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.49\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.51\",\"type\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"arrow\",\"domain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"codomain\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}}},\"value\":{\"kind\":\"projection\",\"type_name\":\"HAdd\",\"index\":0,\"value\":\"_uniq.50\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.52\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"1\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.53\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.52\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.54\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.53\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.55\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"apply\",\"function\":\"_uniq.51\",\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.21\"},{\"kind\":\"fvar\",\"id\":\"_uniq.54\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.56\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Option\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"Option.some\",\"levels\":[\"0\"],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.55\"}]},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.56\"}}}}}}}}}}]}}}}]}}}}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.60\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"literal\",\"literal\":{\"kind\":\"nat\",\"value\":\"0\"}},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.61\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"OfNat\",\"levels\":[\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"any\"}]},\"value\":{\"kind\":\"const\",\"name\":\"instOfNatNat\",\"levels\":[],\"arguments\":[{\"kind\":\"fvar\",\"id\":\"_uniq.60\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.62\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"OfNat\",\"index\":0,\"value\":\"_uniq.61\"},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.63\",\"type\":{\"kind\":\"app\",\"head\":{\"kind\":\"const\",\"name\":\"Prod\",\"levels\":[\"0\",\"0\"]},\"arguments\":[{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},{\"kind\":\"const\",\"name\":\"Bool\",\"levels\":[]}]},\"value\":{\"kind\":\"const\",\"name\":\"LexLeanCollections.iterateUntil\",\"levels\":[],\"arguments\":[{\"kind\":\"type\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]}},{\"kind\":\"fvar\",\"id\":\"_uniq.59\"},{\"kind\":\"fvar\",\"id\":\"_uniq.19\"},{\"kind\":\"fvar\",\"id\":\"_uniq.62\"}]},\"body\":{\"kind\":\"let\",\"id\":\"_uniq.64\",\"type\":{\"kind\":\"const\",\"name\":\"Nat\",\"levels\":[]},\"value\":{\"kind\":\"projection\",\"type_name\":\"Prod\",\"index\":0,\"value\":\"_uniq.63\"},\"body\":{\"kind\":\"return\",\"id\":\"_uniq.64\"}}}}}}}},\"uses\":[\"Add\",\"Bool\",\"ByteArray\",\"Decidable\",\"HAdd\",\"Nat\",\"OfNat\",\"Option\",\"Prod\",\"instAddNat\",\"instDecidableEqBool\",\"instHAdd\",\"instOfNatNat\",\"Bool.true\",\"Decidable.isFalse\",\"Decidable.isTrue\",\"LexLeanCollections.iterateUntil\",\"Nat.blt\",\"Option.none\",\"Option.some\",\"LexLeanStd.Text.spaceAt\"]},\"inductive\":null},{\"name\":\"LexLeanStd.Text.joinWith.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.sliceOr.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"ByteArray\",\"Option\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null},{\"name\":\"LexLeanStd.Text.spaceAt.match_1\",\"kind\":\"definition\",\"module\":\"LexLeanStd.Text\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"definition\",\"internal\":false,\"kernel_uses\":[\"Option\",\"UInt8\",\"Unit\",\"Option.casesOn\",\"Option.none\",\"Option.some\",\"Unit.unit\"],\"declaration\":null,\"inductive\":null}],\"externals\":[{\"name\":\"Add\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Array\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"BEq\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Bool\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"ByteArray\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Decidable\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"GetElem?\",\"kind\":\"inductive\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HAdd\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"HSub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"List\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Nat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"OfNat\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Option\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"PUnit\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Prod\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"Sub\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"UInt8\",\"kind\":\"inductive\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"inductive\",\"internal\":false,\"compiled\":false},{\"name\":\"instAddNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instBEqOfDecidableEq\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqBool\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instDecidableEqUInt8\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHAdd\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instHSub\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instOfNatNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"instSubNat\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Array.instGetElem?NatLtSize\",\"kind\":\"definition\",\"module\":\"Init.GetElem\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Bool.false\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"Bool.true\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Bool\"},{\"name\":\"ByteArray.data\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.extract\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.fastAppend\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.instBEq\",\"kind\":\"definition\",\"module\":\"Init.Data.ByteArray.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"ByteArray.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":true,\"inductive_type\":\"ByteArray\"},{\"name\":\"ByteArray.size\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Decidable.isFalse\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"Decidable.isTrue\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Decidable\"},{\"name\":\"List.cons\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.foldl\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"List.nil\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"List\"},{\"name\":\"List.toArray\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.ble\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.blt\",\"kind\":\"definition\",\"module\":\"Init.Data.Nat.Basic\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.decLe\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Nat.succ\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Nat.zero\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Nat\"},{\"name\":\"Option.none\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Option.some\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Option\"},{\"name\":\"Prod.mk\",\"kind\":\"constructor\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":false,\"original_kind\":\"constructor\",\"internal\":false,\"compiled\":false,\"inductive_type\":\"Prod\"},{\"name\":\"UInt8.instOfNat\",\"kind\":\"definition\",\"module\":\"Init.Data.UInt.BasicAux\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true},{\"name\":\"Unit.unit\",\"kind\":\"definition\",\"module\":\"Init.Prelude\",\"computable\":true,\"generates_code\":true,\"original_kind\":\"definition\",\"internal\":false,\"compiled\":true}]}\n","stdout_sha256":"fbd831ab2f1b732386c68cc6e61810df6cc71d4cb8500118007439491f5d6988","tool":"lean"} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0.lean similarity index 97% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0.lean index 3da19ec4e..ca1dd97d6 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -30,4 +30,4 @@ def denote (subject : ByteArray) («prefix» : ByteArray) : _root_.LexLeanPreser theorem root (subject : ByteArray) («prefix» : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.bytes «prefix»)] (_root_.LexLeanPreservation.Rel (__fits_0 subject «prefix») (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.startsWith subject «prefix»))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject «prefix») -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/Compose/RustStd.lex.tex similarity index 94% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/Compose/RustStd.lex.tex index d255d19bb..26a96019b 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.root : @916 := @917 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.root : @916 := @917 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.flags @3 := ByteArray @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -83,7 +83,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.root @17 @73 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,13 +194,13 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.denote +@322 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.__fits_0 +@325 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.__fits_0 @327 := @325 @4 @15 @330 := LexLeanStd.Text.startsWith @4 @15 @332 := LexLeanTarget.TargetSyntax.Value.bool @330 -@335 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.root @4 @15 +@335 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.root @4 @15 @336 := Bool @337 := Ne.{1} @338 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/RustStd.lean similarity index 97% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/RustStd.lean index 4c1c26df3..fccf1852a 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1.lean similarity index 98% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1.lean index a191ace59..f2ad32497 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -30,4 +30,4 @@ def denote (subject : ByteArray) (suffix : ByteArray) : _root_.LexLeanPreservati theorem root (subject : ByteArray) (suffix : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.bytes suffix)] (_root_.LexLeanPreservation.Rel (__fits_0 subject suffix) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.endsWith subject suffix))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject suffix) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/Compose/RustStd.lex.tex similarity index 94% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/Compose/RustStd.lex.tex index 78c69ee32..781f2e253 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.root : @916 := @917 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.root : @916 := @917 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.flags @3 := ByteArray @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -83,7 +83,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.root @17 @73 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,13 +194,13 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.denote +@322 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.__fits_0 +@325 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.__fits_0 @327 := @325 @4 @15 @330 := LexLeanStd.Text.endsWith @4 @15 @332 := LexLeanTarget.TargetSyntax.Value.bool @330 -@335 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.root @4 @15 +@335 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.root @4 @15 @336 := Bool @337 := Ne.{1} @338 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/RustStd.lean similarity index 98% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/RustStd.lean index 0fdc74d6b..3def2d16d 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -30,4 +30,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2.lean index 4f87c9214..e62f457c1 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -102,4 +102,4 @@ def denote (subject : ByteArray) : _root_.LexLeanPreservation.Obs := theorem root (subject : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (_root_.LexLeanPreservation.Rel (__fits_0 subject) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.trim subject))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/Compose/RustStd.lex.tex similarity index 93% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/Compose/RustStd.lex.tex index 293a60c00..65d0129e0 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.root : @826 := @827 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.root : @826 := @827 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.flags @3 := ByteArray @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -72,7 +72,7 @@ @87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 @92 := List.getD.{0} @72 @74 @61 @87 @96 := fun (__e_n : @57) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.root @17 @61 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.root @17 @61 @97 := LexLeanPreservation.Rust.WTL @105 := {p : @8} -> {c : @9} -> {A : @10} -> @97 @14 @4 @17 @53 @77 @107 := LexLeanPreservation.Rust.wtl_nil @0 @@ -159,12 +159,12 @@ @269 := @263 @121 @270 := @122 @56 @271 := @270 @259 -@272 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.denote +@272 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.denote @273 := @272 @4 -@274 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.__fits_0 +@274 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.__fits_0 @275 := @274 @4 @278 := @5 (LexLeanStd.Text.trim @4) -@280 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.root @4 +@280 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.root @4 @281 := Bool @282 := Ne.{1} @283 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/RustStd.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/RustStd.lean index 553fabe02..3ce36ff6c 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -104,4 +104,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3.lean index 032270123..d42ab4b81 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -85,4 +85,4 @@ def denote (subject : ByteArray) (delimiter : UInt8) : _root_.LexLeanPreservatio theorem root (subject : ByteArray) (delimiter : UInt8) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.u8 delimiter)] (_root_.LexLeanPreservation.Rel (__fits_0 subject delimiter) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.splitOn subject delimiter))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject delimiter) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/Compose/RustStd.lex.tex similarity index 94% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/Compose/RustStd.lex.tex index 7c7682b0f..8320c48c9 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.root : @979 := @980 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.root : @979 := @980 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.flags @3 := ByteArray @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -94,7 +94,7 @@ @126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 @131 := List.getD.{0} @111 @113 @101 @126 @135 := fun (__e_n : @91) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.root @17 @101 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.root @17 @101 @136 := LexLeanPreservation.Rust.WTL @144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 @146 := LexLeanPreservation.Rust.wtl_nil @0 @@ -215,13 +215,13 @@ @366 := @360 @308 @367 := @161 @90 @368 := @367 @356 -@369 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.denote +@369 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.denote @371 := @369 @4 @15 -@372 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.__fits_0 +@372 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.__fits_0 @374 := @372 @4 @15 @377 := LexLeanStd.Text.splitOn @4 @15 @381 := LexLeanPreservation.encList @3 @5 @377 -@384 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.root @4 @15 +@384 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.root @4 @15 @385 := Bool @386 := Ne.{1} @387 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/RustStd.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/RustStd.lean index a04bfa1f3..38faf3b98 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -98,4 +98,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4.lean index fdb451660..d92fdfe57 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -102,4 +102,4 @@ def denote (subject : ByteArray) : _root_.LexLeanPreservation.Obs := theorem root (subject : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (_root_.LexLeanPreservation.Rel (__fits_0 subject) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.lines subject))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/Compose/RustStd.lex.tex similarity index 93% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/Compose/RustStd.lex.tex index 158e25055..01d2a88ec 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.root : @829 := @830 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.root : @829 := @830 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.flags @3 := ByteArray @4 := #1 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -72,7 +72,7 @@ @87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 @92 := List.getD.{0} @72 @74 @61 @87 @96 := fun (__e_n : @57) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.root @17 @61 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.root @17 @61 @97 := LexLeanPreservation.Rust.WTL @105 := {p : @8} -> {c : @9} -> {A : @10} -> @97 @14 @4 @17 @53 @77 @107 := LexLeanPreservation.Rust.wtl_nil @0 @@ -159,13 +159,13 @@ @269 := @263 @121 @270 := @122 @56 @271 := @270 @259 -@272 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.denote +@272 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.denote @273 := @272 @4 -@274 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.__fits_0 +@274 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.__fits_0 @275 := @274 @4 @277 := LexLeanStd.Text.lines @4 @281 := LexLeanPreservation.encList @3 @5 @277 -@283 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.root @4 +@283 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.root @4 @284 := Bool @285 := Ne.{1} @286 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/RustStd.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/RustStd.lean index a96b1dfd9..3658c6761 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -114,4 +114,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5.lean similarity index 98% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5.lean index f8ef8912c..b93bfb543 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -40,4 +40,4 @@ def denote (pieces : (List ByteArray)) (separator : ByteArray) : _root_.LexLeanP theorem root (pieces : (List ByteArray)) (separator : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) pieces), (_root_.LexLeanTarget.TargetSyntax.Value.bytes separator)] (_root_.LexLeanPreservation.Rel (__fits_0 pieces separator) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.joinWith pieces separator))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 pieces separator) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/Compose/RustStd.lex.tex similarity index 94% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/Compose/RustStd.lex.tex index d1956bdd9..2edcf9b7a 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.root : @1046 := @1047 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.root : @1046 := @1047 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.flags @3 := ByteArray @4 := List.{0} @5 := @4 @3 @@ -133,7 +133,7 @@ @207 := LexLeanTarget.TargetSyntax.Function.mk @196 @197 @198 @202 @212 := List.getD.{0} @193 @195 @183 @207 @216 := fun (__e_n : @173) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.root @15 @183 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.root @15 @183 @217 := LexLeanPreservation.Rust.WTL @225 := {p : @16} -> {c : @17} -> {A : @18} -> @217 @6 @23 @15 @167 @197 @227 := LexLeanPreservation.Rust.wtl_nil @0 @@ -243,12 +243,12 @@ @436 := @430 @378 @437 := @242 @172 @438 := @437 @426 -@439 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.denote +@439 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.denote @441 := @439 @6 @23 -@442 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.__fits_0 +@442 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.__fits_0 @444 := @442 @6 @23 @448 := @7 (LexLeanStd.Text.joinWith @6 @23) -@451 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.root @6 @23 +@451 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.root @6 @23 @452 := Bool @453 := Ne.{1} @454 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/RustStd.lean similarity index 98% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/RustStd.lean index af823ea50..5a3af47a0 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -48,4 +48,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6.lean index b24bb5d84..7e48fbb84 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6.lean @@ -11,7 +11,7 @@ set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 set_option linter.unusedVariables false -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6 +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6 def __prog : _root_.LexLeanTarget.TargetSyntax.Program := { adts := [], functions := [ @@ -50,4 +50,4 @@ def denote (subject : ByteArray) (needle : ByteArray) : _root_.LexLeanPreservati theorem root (subject : ByteArray) (needle : ByteArray) : _root_.LexLeanPreservation.RunConv __prog 0 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.bytes needle)] (_root_.LexLeanPreservation.Rel (__fits_0 subject needle) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (LexLeanStd.Text.find subject needle))) := _root_.LexLeanPreservation.run_of_funRel (__rel_0 subject needle) -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6 +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/Compose/RustStd.lex.tex similarity index 94% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/Compose/RustStd.lex.tex rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/Compose/RustStd.lex.tex index 2fabe8930..55ab5ba49 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/Compose/RustStd.lex.tex +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/Compose/RustStd.lex.tex @@ -1,23 +1,23 @@ \begin{lexlean}{RustStd} -\title{Certificate E LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd} +\title{Certificate E LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd} \begin{coremodule} imports [ - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6, - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6, + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd, LexLeanPreservation.Compose ] -theorem LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.root : @919 := @920 { - all: [LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.root], +theorem LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.root : @919 := @920 { + all: [LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.root], class: false, generated: false, policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, transparency: semireducible } -@0 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.program -@1 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.krate -@2 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.flags +@0 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.program +@1 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.krate +@2 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.flags @3 := ByteArray @4 := #2 @5 := LexLeanTarget.TargetSyntax.Value.bytes @@ -83,7 +83,7 @@ @98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 @103 := List.getD.{0} @83 @85 @73 @98 @107 := fun (__e_n : @63) => - LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.root @17 @73 + LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.root @17 @73 @108 := LexLeanPreservation.Rust.WTL @116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 @118 := LexLeanPreservation.Rust.wtl_nil @0 @@ -194,14 +194,14 @@ @319 := @314 @276 @320 := @133 @62 @321 := @320 @310 -@322 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.denote +@322 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.denote @324 := @322 @4 @15 -@325 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.__fits_0 +@325 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.__fits_0 @327 := @325 @4 @15 @330 := LexLeanStd.Text.find @4 @15 @331 := LexLeanTarget.TargetSyntax.Value.nat @335 := LexLeanPreservation.encOption @63 @331 @330 -@338 := LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.root @4 @15 +@338 := LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.root @4 @15 @339 := Bool @340 := Ne.{1} @341 := LexLeanPreservation.Obs diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/RustStd.lean similarity index 99% rename from stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/RustStd.lean rename to stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/RustStd.lean index d259d9dfc..68003ab83 100644 --- a/stdlib/expected/verify/preserve/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/RustStd.lean +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/RustStd.lean @@ -3,7 +3,7 @@ set_option autoImplicit false set_option maxRecDepth 100000 set_option maxHeartbeats 0 set_option synthInstance.maxHeartbeats 0 -namespace LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd +namespace LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd open LexLeanTarget LexLeanPreservation.Rust noncomputable def program : TargetSyntax.Program := @@ -56,4 +56,4 @@ theorem crate_ok : CrateOK program krate flags := by /-- Every function of the program is simulated by its rendering. -/ theorem root : ∀ n f, FunSem program krate flags n f := fun n f => simulate crate_ok n f -end LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd +end LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd diff --git a/stdlib/expected/verify/preserve/audit.txt b/stdlib/expected/verify/preserve/audit.txt index 8dd98bb95..47787b060 100644 --- a/stdlib/expected/verify/preserve/audit.txt +++ b/stdlib/expected/verify/preserve/audit.txt @@ -7737,53 +7737,53 @@ 'LexLeanPreservation.encOption.eq_2' does not depend on any axioms 'LexLeanPreservation.encPair.eq_1' does not depend on any axioms 'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.root' depends on axioms: [propext, +'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -- statement vocabulary diff --git a/stdlib/expected/verify/preserve/preservation.json b/stdlib/expected/verify/preserve/preservation.json index f859874f9..9cbad0fea 100644 --- a/stdlib/expected/verify/preserve/preservation.json +++ b/stdlib/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":4532,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0","program":{"byte_length":735,"sha256":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f"},"renderings":[{"byte_length":5198,"composed":{"byte_length":13297,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd","sha256":"2bdc933620d3620d0fc3dc4635acd70e147b67fcd1f459cb6385d48cc63e6959","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.root"},"crate":{"byte_length":13187,"sha256":"ecbb884548b529d7e84909723ca7a81a4faf337126be517c3cfa81827316dc4f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd","sha256":"c53f00c43c4ef46835781f18561013894d0d9be6655834cba12fe799d15780f7","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.root"}],"root":"LexLeanStd.Text.startsWith","sha256":"b64ee490ff995cf99230bae61dbe8c012617cf03c0d5dccf36475ffe983dbe32","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.root"},{"byte_length":7029,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1","program":{"byte_length":1240,"sha256":"2e8cee85b376065a6078160fa53fd52c7a2f6aa31eb349462fb499ef41683e7f"},"renderings":[{"byte_length":9638,"composed":{"byte_length":13295,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd","sha256":"e6c17f4fe90303ad27c624727caf367cd98b60fd90888ad18f3835bfbafcff60","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.root"},"crate":{"byte_length":13540,"sha256":"19d453bddf0fcdb46b45f5a3be483fa281f67e29cfd7888fa747dfc44a7350b1"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd","sha256":"a4b90d0da28d3acfafa0ac2d1ec3de23a461110b4c31abfe075bb0c81cf31d0f","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.root"}],"root":"LexLeanStd.Text.endsWith","sha256":"1b02a0ecf3f09bdd6d64da127c5f51453fd68d360af0e05413c1f6554e539f23","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.root"},{"byte_length":31004,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2","program":{"byte_length":7351,"sha256":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455"},"renderings":[{"byte_length":37513,"composed":{"byte_length":12066,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd","sha256":"553487714fc340ccb866fe40464b304135d53f3fcd46411ca4ff001de72d2177","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.root"},"crate":{"byte_length":15976,"sha256":"682968e0ba898d7ddd56862ff4f443cb9918653229002af6c18a4c31df0a007c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd","sha256":"c413721f0d6454a827df2d9f6e66d1b956ef7c92cca8d1cfb15d55483cfffcee","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.root"}],"root":"LexLeanStd.Text.trim","sha256":"b52a74bd74d96637d23cd387dc173face7e021c84f63baae440a17e9502f0104","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.root"},{"byte_length":30155,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3","program":{"byte_length":10335,"sha256":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3"},"renderings":[{"byte_length":41781,"composed":{"byte_length":14062,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd","sha256":"2353ce1e79b7bc52a8aa458ffd33028453a0c21838d96a9c527146bef2f96614","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.root"},"crate":{"byte_length":16698,"sha256":"e7f7355f576d9a156f1a77d9659f9a15f11bc2d2764284bdbde923db1853fc6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd","sha256":"830562095f667d1473a0cfd611af2c90291af8d0b4468c5bb9c63f9f94a887d9","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.root"}],"root":"LexLeanStd.Text.splitOn","sha256":"2bbf89e0dec713488afbba73b8801f49323e149c5b015dba6deaa907b59369e6","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.root"},{"byte_length":40549,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4","program":{"byte_length":12480,"sha256":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea"},"renderings":[{"byte_length":56039,"composed":{"byte_length":12109,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd","sha256":"ff0f4a425553072daf795370e00c678278f2ad99b33aa33daa993a1597be3b83","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.root"},"crate":{"byte_length":17906,"sha256":"4ea4e572ad6fca908ee188267f4b1f7ca812087ee75b178dd81932fdc7c99ae9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd","sha256":"6dc1b6d83656c7c6900e339c55c5151d804514feac9934cf37ae7695a4f440e1","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.root"}],"root":"LexLeanStd.Text.lines","sha256":"3dabe9135fb78d47c886b0fb240fc71b64dc3d0143c0883d633f2e7fd5631168","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.root"},{"byte_length":9823,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5","program":{"byte_length":2224,"sha256":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a"},"renderings":[{"byte_length":11921,"composed":{"byte_length":14998,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd","sha256":"a5fac8cb6d6358086da41dfb85f806261d8e2297848d73da761a34e82e33706b","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.root"},"crate":{"byte_length":13992,"sha256":"539c1cc369fa726faf19d46f599ba91d3735bb6ce3ae1f6a9154eea8e86ae9a8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd","sha256":"da8d78eff4d6c5e0471696a0bc5aa14e8ddbaefaf26eaa8b83054fd660ad34cb","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.root"}],"root":"LexLeanStd.Text.joinWith","sha256":"a097d695ee2679a5bdbc18a37971101c785a50a72bd9b0c57eb37abd15440eeb","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.root"},{"byte_length":17309,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6","program":{"byte_length":4379,"sha256":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178"},"renderings":[{"byte_length":23324,"composed":{"byte_length":13336,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd","sha256":"fbac6066b70e4db07c4cc88bc68b6a8526feb50bc29252121bff341eea70ee7b","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.root"},"crate":{"byte_length":14897,"sha256":"67e641527ec2d8c918047395e0b99d352b8270a3ef51124149af1a42548661d2"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd","sha256":"56a8161a65c6a1c280703afc2463761aad1f5511fdfd9a390dd4f5aac348c415","target":"rust-std","theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.root"}],"root":"LexLeanStd.Text.find","sha256":"96cc2c1d317b67c90d7e372ee4ba70ac93825e9863c6d199841c0cb113ef774d","targets":["rust-std"],"theorem":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":4532,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0","program":{"byte_length":735,"sha256":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f"},"renderings":[{"byte_length":5198,"composed":{"byte_length":13297,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd","sha256":"c011e229c3f2ee9ca57ed101a5d687b086456d34adf6506fe868e6e695f635df","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.root"},"crate":{"byte_length":13187,"sha256":"ecbb884548b529d7e84909723ca7a81a4faf337126be517c3cfa81827316dc4f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd","sha256":"518e018ac6183b75e497378a0888668b6e97b58ac3d288c692c001a5c5d1c3f7","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.root"}],"root":"LexLeanStd.Text.startsWith","sha256":"db5df81486e22cb6479d944737e401f2309abcf8a5919e271e0b15ac52774e50","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.root"},{"byte_length":7029,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1","program":{"byte_length":1240,"sha256":"2e8cee85b376065a6078160fa53fd52c7a2f6aa31eb349462fb499ef41683e7f"},"renderings":[{"byte_length":9638,"composed":{"byte_length":13295,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd","sha256":"f45de915712947556d7653d87d65d1e9ce56e364de53244556f7dc3d9bb82873","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.root"},"crate":{"byte_length":13540,"sha256":"19d453bddf0fcdb46b45f5a3be483fa281f67e29cfd7888fa747dfc44a7350b1"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd","sha256":"2771ff020e685e063506464232d065727baccc3acac977d7a22f56288db174e8","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.root"}],"root":"LexLeanStd.Text.endsWith","sha256":"82276f437dfdcdf2a93c3d565e7fd6108c92509efd3e6969d1e54ae08d48ef49","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.root"},{"byte_length":31004,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2","program":{"byte_length":7351,"sha256":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455"},"renderings":[{"byte_length":37513,"composed":{"byte_length":12066,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd","sha256":"e257edcceb6081d9e8ff6183bcbed1d3862e10247ab0ae40044c14ac92800b8d","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.root"},"crate":{"byte_length":15976,"sha256":"682968e0ba898d7ddd56862ff4f443cb9918653229002af6c18a4c31df0a007c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd","sha256":"baf50eeec82c5fed4d855479961ba0276cd61bf8416ac4da696704b372834059","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.root"}],"root":"LexLeanStd.Text.trim","sha256":"c2da3fcb73bda0f501fee3f000956fc90b6e8915f21ea9b68bc54a34ca0e958c","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.root"},{"byte_length":30155,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3","program":{"byte_length":10335,"sha256":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3"},"renderings":[{"byte_length":41781,"composed":{"byte_length":14062,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd","sha256":"97ea05fb8cac84383bb777e091dfd6ed8adc180704b73ba8035d19d22351c4ce","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.root"},"crate":{"byte_length":16698,"sha256":"e7f7355f576d9a156f1a77d9659f9a15f11bc2d2764284bdbde923db1853fc6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd","sha256":"0c8ad5a69fd2e9fe02814b9ba71c4b70c5451e4446d033f091dca76d3504490d","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.root"}],"root":"LexLeanStd.Text.splitOn","sha256":"b0f75a4538c200f1c75bf88df29f0ff8111016f945e13a90f42627756a6dc095","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.root"},{"byte_length":40549,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4","program":{"byte_length":12480,"sha256":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea"},"renderings":[{"byte_length":56039,"composed":{"byte_length":12109,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd","sha256":"a3f486b7f4c4d32a286e4f97aa2dead4616231f31203e9411665f23e971489ce","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.root"},"crate":{"byte_length":17906,"sha256":"4ea4e572ad6fca908ee188267f4b1f7ca812087ee75b178dd81932fdc7c99ae9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd","sha256":"a2e416e6c2bb49b35d32be911ae159669532b44ffb5ce86434d32bcf4261f07a","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.root"}],"root":"LexLeanStd.Text.lines","sha256":"723913dae06e8b8ad93f4917e8d0870287d0255ad08db19b6d7264d79f5f2f65","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.root"},{"byte_length":9823,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5","program":{"byte_length":2224,"sha256":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a"},"renderings":[{"byte_length":11921,"composed":{"byte_length":14998,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd","sha256":"530c2af7658c6abe7ca0860d61f9d2937a6aaf1da2b9746f3184d07e60f97700","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.root"},"crate":{"byte_length":13992,"sha256":"539c1cc369fa726faf19d46f599ba91d3735bb6ce3ae1f6a9154eea8e86ae9a8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd","sha256":"f1cd19fd82f5e0b8dd87e412c2045ed477a5278808e03b3119d232920564f543","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.root"}],"root":"LexLeanStd.Text.joinWith","sha256":"b37af28d9a713741b3135b314dbecb59320531baadb1f2942c0f1d06e18665f0","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.root"},{"byte_length":17309,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6","program":{"byte_length":4379,"sha256":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178"},"renderings":[{"byte_length":23324,"composed":{"byte_length":13336,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd","sha256":"c5e346c4c2afb6277446451683c51871c6cc63bf76cfed82c4aa0fba5f3983df","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.root"},"crate":{"byte_length":14897,"sha256":"67e641527ec2d8c918047395e0b99d352b8270a3ef51124149af1a42548661d2"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd","sha256":"0bff6fde2b1a81d541357d4855e9a5ca792607329f0570d691dac7f142b2e69f","target":"rust-std","theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.root"}],"root":"LexLeanStd.Text.find","sha256":"d3575be4612b4d5cd8513e74ca728ef4a2a165d99a081d3b132a723d3e6d10a6","targets":["rust-std"],"theorem":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.root"}],"spec":"lexlean/preservation/1"} diff --git a/stdlib/expected/verify/probe/LexLeanProbe.P5bfc6ad2db2940a1b7735f1309be47dc.lean b/stdlib/expected/verify/probe/LexLeanProbe.Pf6fd2434413f885eb97b3577e92c0706.lean similarity index 100% rename from stdlib/expected/verify/probe/LexLeanProbe.P5bfc6ad2db2940a1b7735f1309be47dc.lean rename to stdlib/expected/verify/probe/LexLeanProbe.Pf6fd2434413f885eb97b3577e92c0706.lean diff --git a/stdlib/expected/verify/probe/process.json b/stdlib/expected/verify/probe/process.json index daf0eb131..99385102c 100644 --- a/stdlib/expected/verify/probe/process.json +++ b/stdlib/expected/verify/probe/process.json @@ -1 +1 @@ -{"argv":["env","lean","$STAGING/probe/LexLeanProbe.P5bfc6ad2db2940a1b7735f1309be47dc.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.P5bfc6ad2db2940a1b7735f1309be47dc","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pf6fd2434413f885eb97b3577e92c0706.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pf6fd2434413f885eb97b3577e92c0706","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json deleted file mode 100644 index 97077d9d6..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json deleted file mode 100644 index fd8dd2663..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json deleted file mode 100644 index 5bd64d760..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json deleted file mode 100644 index e8ff03675..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json deleted file mode 100644 index 795225b28..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json deleted file mode 100644 index 65ac7c670..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json deleted file mode 100644 index ac25fe22c..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json deleted file mode 100644 index 22ae4b2de..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json deleted file mode 100644 index 13bd245cb..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json deleted file mode 100644 index ce74a66d1..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json deleted file mode 100644 index 57161976f..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json deleted file mode 100644 index f5dcaa0fc..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json deleted file mode 100644 index f22250120..000000000 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json similarity index 58% rename from bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json rename to stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json index 272083c41..178a6c81b 100644 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd.json +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json new file mode 100644 index 000000000..bb126a5e3 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json new file mode 100644 index 000000000..57d14cb3c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json similarity index 58% rename from bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json rename to stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json index 908bafbea..13c93b901 100644 --- a/bootstrap/expected/verify/process/leanchecker/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json new file mode 100644 index 000000000..abc0b1851 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json new file mode 100644 index 000000000..ce1fc48d5 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json similarity index 58% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json rename to stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json index 6f1f47a1b..e2e24baaa 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.json +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json new file mode 100644 index 000000000..c2b94f34a --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json new file mode 100644 index 000000000..10196f8e7 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json similarity index 58% rename from stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json rename to stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json index 8768e9f63..5be8224f7 100644 --- a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json new file mode 100644 index 000000000..a2389828b --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json new file mode 100644 index 000000000..ee58c12eb --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json new file mode 100644 index 000000000..d2f0b5935 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json new file mode 100644 index 000000000..b669750d9 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json new file mode 100644 index 000000000..0f60f44d8 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json new file mode 100644 index 000000000..5ce611cb0 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json new file mode 100644 index 000000000..a3ad2376b --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json new file mode 100644 index 000000000..7a30851ce --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json new file mode 100644 index 000000000..20baed3ac --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json new file mode 100644 index 000000000..3ef79d7aa --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json new file mode 100644 index 000000000..aa148a77c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 6d565b063..7fdf0f100 100644 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"4de95c12e7eaaeff267cf066492be69b0bbd7bd87f0e5539e96c7f3ad347d329","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"533b2c450cac3e595b71c9b8c9ed4d95073ce958a955b6fd2ee5ce1d5d38ff06","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json deleted file mode 100644 index d3dc808f9..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json deleted file mode 100644 index 05c3c0fbc..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json deleted file mode 100644 index a47243a97..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json deleted file mode 100644 index 5ae941a8b..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json deleted file mode 100644 index 3e04bb746..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json deleted file mode 100644 index 24f41ca1a..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json deleted file mode 100644 index b018b012f..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json deleted file mode 100644 index 125dcc515..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json deleted file mode 100644 index 6e99666d2..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json deleted file mode 100644 index 842b74f8b..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json deleted file mode 100644 index 5577d5788..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json deleted file mode 100644 index 44c3e49da..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json deleted file mode 100644 index 08e1e1a0f..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json deleted file mode 100644 index 2cbdb2be3..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json deleted file mode 100644 index 036ffb70e..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json deleted file mode 100644 index 5b61a9596..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json deleted file mode 100644 index 9c8a8f5eb..000000000 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6.json +++ /dev/null @@ -1 +0,0 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json similarity index 57% rename from stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json rename to stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json index 97042ff7a..ef428edac 100644 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd.json +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json similarity index 55% rename from stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json rename to stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json index ce06d3eb8..496e92e8c 100644 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd.json +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json new file mode 100644 index 000000000..f93f6df26 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json similarity index 57% rename from bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json rename to stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json index c564c6c10..5af9a4f78 100644 --- a/bootstrap/expected/verify/process/preserve/LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd.json +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cadb40bbfc73b1dc6b7a95dab0c348a27/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cadb40bbfc73b1dc6b7a95dab0c348a27.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json similarity index 55% rename from stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json rename to stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json index a970af413..3b861bb54 100644 --- a/stdlib/expected/verify/process/preserve/LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd.json +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/C5bfc6ad2db2940a1b7735f1309be47dc/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.C5bfc6ad2db2940a1b7735f1309be47dc.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json new file mode 100644 index 000000000..3e96cbfd6 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json new file mode 100644 index 000000000..c3352ea2d --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json new file mode 100644 index 000000000..191ee58a1 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json new file mode 100644 index 000000000..dde7829d0 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json new file mode 100644 index 000000000..2e4d76f1a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json new file mode 100644 index 000000000..54d943e7a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json new file mode 100644 index 000000000..384e977d9 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json new file mode 100644 index 000000000..80a67ae49 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json new file mode 100644 index 000000000..331a745ff --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json new file mode 100644 index 000000000..821e47f94 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json new file mode 100644 index 000000000..4b049940e --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json new file mode 100644 index 000000000..49de03e4d --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json new file mode 100644 index 000000000..0ee4945e6 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json new file mode 100644 index 000000000..60670caa9 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json new file mode 100644 index 000000000..1c012ad1f --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json new file mode 100644 index 000000000..168d7e7ab --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6.olean","$STAGING/preserve-src/LexLeanPreserve/Cf6fd2434413f885eb97b3577e92c0706/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cf6fd2434413f885eb97b3577e92c0706.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/package.json b/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/package.json index bc807221c..9a6e75a13 100644 --- a/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/package.json +++ b/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"is_closed_lean_name","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}]}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"function":5,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":2}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"46"}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"65"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"90"}}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"97"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"122"}}]},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"95"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"63"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"39"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]}],"spec":"lexlean/target-program/1"},"sources":["adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own"]}],"name":"is_closed_lean_name","profile":"rust-std","program":{"adts":[],"functions":[{"body":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"first","value":{"function":1,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":2,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}]}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":1,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":3,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"function":5,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":2}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":4,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"46"}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"condition":{"function":7,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"65"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"90"}}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"97"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"122"}}]},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"95"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":6,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":8,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"63"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"39"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]}],"spec":"lexlean/target-program/1"},"sources":["5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/provenance.json b/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/provenance.json index 727bb0f8c..ac459ee11 100644 --- a/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/provenance.json +++ b/tests/production-export/bootstrap/packages/rust-std/is_closed_lean_name/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"db6c409513536a098e42c8eb670502c59d8e535f0d767a3bba391a04526306e1","src/lib.rs":"2d0cbaacd46e3c30b7222bca6c20676ba67a79e6bd6b2ab4b1a7775ad8c9ce28"},"name":"is_closed_lean_name","profile":"rust-std","program":"730de4e60a1096efe498df077205f9916491d21aa78c6f1a197a1898349209f2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"db6c409513536a098e42c8eb670502c59d8e535f0d767a3bba391a04526306e1","src/lib.rs":"2d0cbaacd46e3c30b7222bca6c20676ba67a79e6bd6b2ab4b1a7775ad8c9ce28"},"name":"is_closed_lean_name","profile":"rust-std","program":"730de4e60a1096efe498df077205f9916491d21aa78c6f1a197a1898349209f2","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/package.json b/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/package.json index 3a6690208..a6f4b2907 100644 --- a/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/package.json +++ b/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/package.json @@ -1 +1 @@ -{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"parse_audit_output","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]]},{"constructors":[[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}],[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}],[{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"option","value":{"kind":"bytes"}}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"function":2,"kind":"call","operands":[{"captures":[],"function":3,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"constructor":2,"kind":"adt"}},{"binders":[3,4,5,6],"body":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unterminated axiom payload: "}}]},{"kind":"var","name":5}]},{"kind":"var","name":6}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7,8],"body":{"body":{"condition":{"kind":"prim","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":7}]},{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"var","name":9},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"captures":[],"function":12,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},{"function":13,"kind":"call","operands":[{"kind":"var","name":7}]}]}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"expected "}}]},{"function":8,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]}]}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" audit records, found "}}]}]},{"function":8,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":7}]}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":9,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"index":1,"kind":"adt"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":1,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":1,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"},{"kind":"bytes"}],"result":{"index":1,"kind":"adt"}},{"index":1,"kind":"adt"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"},{"kind":"bytes"}]},{"body":{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":17,"kind":"call","operands":[{"kind":"var","name":4}]},"kind":"cond","then_branch":{"function":17,"kind":"call","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":15,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":16,"kind":"closure"},{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":2,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"}]},{"body":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"append"}},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"utf8_encode"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"string"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"function":20,"kind":"call","operands":[{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}]},{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}]},"kind":"let","name":2,"type":{"kind":"bytes"}},"bound":{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0"}}]},"kind":"let","name":1,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"nat"}]},{"body":{"function":22,"kind":"call","operands":[{"captures":[],"function":23,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":24,"kind":"call","operands":[{"captures":[],"function":25,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}]},{"body":{"function":27,"kind":"call","operands":[{"captures":[],"function":28,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"constructor":2,"kind":"adt"}},{"binders":[3,4,5,6],"body":{"arms":[{"binders":[7],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":4},{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":5},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" "}}]}]},{"kind":"var","name":7}]},{"kind":"var","name":6}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unterminated axiom payload: "}}]},{"kind":"var","name":5}]},{"kind":"var","name":6}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":29,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"index":1,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[8,9],"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[10],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":8},{"kind":"var","name":9},{"kind":"var","name":10},{"function":34,"kind":"call","operands":[{"kind":"var","name":9}]}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unrecognized audit line: "}}]},{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}]},{"function":34,"kind":"call","operands":[{"kind":"var","name":9}]}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":33,"kind":"call","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}]},"type":{"index":1,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"var","name":0}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":1,"kind":"adt"}},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":36,"kind":"call","operands":[{"captures":[],"function":37,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"index":0,"kind":"adt"},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}]},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":39,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"function":18,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0123456789"}}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"bytes"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"index":2,"kind":"adt"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"kind":"error"}},{"binders":[3],"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":5}],"operation":{"kind":"equal"}},"else_branch":{"kind":"var","name":7},"kind":"cond","then_branch":{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"var","name":6},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":41,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":3}]},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"expected a record for "}}]},{"function":40,"kind":"call","operands":[{"kind":"var","name":5}]}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":", found "}}]}]},{"function":40,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}]},{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":7,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"duplicate record for "}}]},{"function":40,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}]},{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":6,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"bound":{"arms":[{"binders":[4],"body":{"kind":"var","name":4},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"bytes"}},"kind":"let","name":5,"type":{"kind":"bytes"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":2,"kind":"adt"}],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":2,"kind":"adt"}]},{"body":{"body":{"condition":{"function":42,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}}}},"bound":{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":43,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"function":31,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":3}]},"shape":{"kind":"error"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":5}},{"kind":"second","value":{"kind":"var","name":5}},{"kind":"var","name":3}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"function":45,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"function":44,"kind":"call","operands":[{"kind":"var","name":2}]},"type":{"index":1,"kind":"adt"}}},"parameters":[0,1,2,3],"result":{"index":1,"kind":"adt"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"body":{"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}]},"bound":{"function":47,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"function":46,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":48,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"'"}}]}]},"else_branch":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":50,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"info: "}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":5},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":52,"kind":"call","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"function":53,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"`"}}]},{"kind":"var","name":0}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"`"}}]}]},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":54,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":3}}]},"else_branch":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":41,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" does not depend on any axioms"}}]}]},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"]"}}]}]},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"var","name":4},"kind":"cond","then_branch":{"kind":"var","name":3}},"bound":{"function":59,"kind":"call","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":2}]}]},"kind":"let","name":4,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":58,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"kind":"let","name":3,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[5],"body":{"function":62,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":5}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"]"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"' does not depend on any axioms"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"'"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"var","name":2},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":63,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":64,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}]}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"function":48,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"arms":[{"binders":[2],"body":{"arms":[{"binders":[3],"body":{"body":{"body":{"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":7}},"bound":{"function":66,"kind":"call","operands":[{"kind":"var","name":5},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":3}},"kind":"let","name":6,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":3}},"kind":"let","name":5,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":68,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0d","kind":"bytes"}}]},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"9"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"13"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"32"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"194"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"225"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"226"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"227"}}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"129"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"159"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"138"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"168"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"169"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"175"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"154"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"133"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"160"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":68,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"function":59,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unrecognized axiom payload: "}}]},{"kind":"var","name":0}]}]},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"function":6,"kind":"call","operands":[{"function":40,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" is not a Lean name"}}]}]},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"first","value":{"function":71,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":72,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}]}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"var","name":6},"kind":"cond","then_branch":{"kind":"var","name":5}},"bound":{"function":59,"kind":"call","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":3}]}]},"kind":"let","name":6,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":74,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":4}]},"kind":"let","name":5,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"second","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":73,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"' depends on axioms: ["}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}]},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":76,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"body":{"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":8}}}},"bound":{"function":77,"kind":"call","operands":[{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":5}},"kind":"let","name":7,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":5}},"kind":"let","name":6,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":9}},"bound":{"function":77,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":9,"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"function":78,"kind":"call","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[4],"body":{"function":79,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":2},{"kind":"var","name":3}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1,2,3],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":71,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":80,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":4}]},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}}},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":81,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"function":59,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"error"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"function":59,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"an axiom list cannot be empty"}}]}]},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":58,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":3},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"function":83,"kind":"call","operands":[{"captures":[],"function":84,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},{"function":85,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"44"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"var","name":1}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}}},"else_branch":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"var","name":1}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":3},{"kind":"var","name":0},{"kind":"var","name":2}],"function":86,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"function":49,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"info: "}}]}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" "}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":88,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":3}}},"bound":{"function":87,"kind":"call","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":2}]}]},"kind":"let","name":3,"type":{"kind":"bool"}},"bound":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"+"}}]}]},"type":{"kind":"bytes"}},"kind":"let","name":2,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"function":89,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":2}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":90,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":83,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1,2],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":91,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}]},{"body":{"body":{"body":{"body":{"function":17,"kind":"call","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":3}}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":3}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":15,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":92,"kind":"closure"},{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":3,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":0},{"kind":"var","name":4}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2,3,4],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"18446744073709551615"}}]}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}}],"operation":{"kind":"bool_not"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":93,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"46"}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":94,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"condition":{"function":95,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"kind":"error"}},{"binders":[3],"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"kind":"cond","then_branch":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"duplicate axiom name "}}]},{"function":40,"kind":"call","operands":[{"kind":"var","name":4}]}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":96,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":3}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":4,"type":{"kind":"bytes"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}]},{"body":{"function":97,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":98,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"65"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"90"}}]},"else_branch":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"97"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"122"}}]},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"95"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":94,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"63"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"39"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":54,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"else_branch":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":96,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[6],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"var","name":5}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":5,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb"],"spec":"lexlean/rust-package/1","version":"1.0.0"} +{"exports":[{"errors":"overflow","function":0,"name":"run","parameters":["own","own"]}],"name":"parse_audit_output","profile":"rust-std","program":{"adts":[{"constructors":[[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]]},{"constructors":[[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}],[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}],[{"index":0,"kind":"adt"}]]},{"constructors":[[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"option","value":{"kind":"bytes"}}]]}],"functions":[{"body":{"function":1,"kind":"call","operands":[{"function":2,"kind":"call","operands":[{"captures":[],"function":3,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},{"function":4,"kind":"call","operands":[{"kind":"var","name":0}]}]},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"var","name":2}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"constructor":2,"kind":"adt"}},{"binders":[3,4,5,6],"body":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unterminated axiom payload: "}}]},{"kind":"var","name":5}]},{"kind":"var","name":6}]},"shape":{"constructor":1,"kind":"adt"}},{"binders":[7,8],"body":{"body":{"condition":{"kind":"prim","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":7}]},{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"var","name":9},"kind":"cond","then_branch":{"function":11,"kind":"call","operands":[{"captures":[],"function":12,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},{"function":13,"kind":"call","operands":[{"kind":"var","name":7}]}]}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"expected "}}]},{"function":8,"kind":"call","operands":[{"function":9,"kind":"call","operands":[{"kind":"var","name":1}]}]}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" audit records, found "}}]}]},{"function":8,"kind":"call","operands":[{"function":10,"kind":"call","operands":[{"kind":"var","name":7}]}]}]},{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":9,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"index":1,"kind":"adt"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":2,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"index":1,"kind":"adt"}},"parameters":[0,1,2],"result":{"index":1,"kind":"adt"},"types":[{"kind":"fn","parameters":[{"index":1,"kind":"adt"},{"kind":"bytes"}],"result":{"index":1,"kind":"adt"}},{"index":1,"kind":"adt"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":14,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"},{"kind":"bytes"}]},{"body":{"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"nat_lt"}},"else_branch":{"function":17,"kind":"call","operands":[{"kind":"var","name":4}]},"kind":"cond","then_branch":{"function":17,"kind":"call","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":15,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":16,"kind":"closure"},{"kind":"var","name":1},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":2,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"}]},{"body":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"kind":"error"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"append"}},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"utf8_encode"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"string"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"var","name":2},"kind":"cond","then_branch":{"kind":"var","name":1}},"bound":{"function":20,"kind":"call","operands":[{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1000"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"100"}}]},{"kind":"prim","operands":[{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}}]},{"function":21,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}],"operation":{"kind":"append"}}]},"kind":"let","name":2,"type":{"kind":"bytes"}},"bound":{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0"}}]},"kind":"let","name":1,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"nat"}]},{"body":{"function":22,"kind":"call","operands":[{"captures":[],"function":23,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":24,"kind":"call","operands":[{"captures":[],"function":25,"kind":"closure"},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"kind":"nat"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":11,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"function":26,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}]},{"body":{"function":27,"kind":"call","operands":[{"captures":[],"function":28,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"constructor":2,"kind":"adt"}},{"binders":[3,4,5,6],"body":{"arms":[{"binders":[7],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":4},{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"kind":"var","name":5},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" "}}]}]},{"kind":"var","name":7}]},{"kind":"var","name":6}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unterminated axiom payload: "}}]},{"kind":"var","name":5}]},{"kind":"var","name":6}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":29,"kind":"call","operands":[{"kind":"var","name":1}]},"type":{"index":1,"kind":"adt"}},"shape":{"constructor":1,"kind":"adt"}},{"binders":[8,9],"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[10],"body":{"function":30,"kind":"call","operands":[{"kind":"var","name":8},{"kind":"var","name":9},{"kind":"var","name":10},{"function":34,"kind":"call","operands":[{"kind":"var","name":9}]}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":31,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unrecognized audit line: "}}]},{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}]},{"function":34,"kind":"call","operands":[{"kind":"var","name":9}]}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":33,"kind":"call","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]}]},"type":{"index":1,"kind":"adt"}},"kind":"cond","then_branch":{"kind":"var","name":0}},"shape":{"constructor":0,"kind":"adt"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"index":1,"kind":"adt"}},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"index":1,"kind":"adt"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":15,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":35,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":36,"kind":"call","operands":[{"captures":[],"function":37,"kind":"closure"},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"var","name":0}]},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"var","name":3},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}],"operation":{"kind":"slice"}},"type":{"kind":"bytes"}},"parameters":[0,1,2],"result":{"kind":"bytes"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":0,"kind":"adt"}},"parameters":[0,1],"result":{"index":0,"kind":"adt"},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}]},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":39,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"function":18,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"0123456789"}}]},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_quot"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"10"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_rem"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}]},"parameters":[0,1],"result":{"kind":"bytes"},"types":[{"kind":"nat"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":22,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"kind":"bytes"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":24,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"nat"},"types":[{"kind":"fn","parameters":[{"kind":"nat"},{"index":2,"kind":"adt"}],"result":{"kind":"nat"}},{"kind":"nat"},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"kind":"error"}},{"binders":[3],"body":{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":5}],"operation":{"kind":"equal"}},"else_branch":{"kind":"var","name":7},"kind":"cond","then_branch":{"arms":[{"binders":[8],"body":{"kind":"build","operands":[{"kind":"var","name":8}],"shape":{"kind":"ok"},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"var","name":6},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":41,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}},{"index":1,"kind":"field","value":{"kind":"var","name":1}},{"kind":"var","name":3}]},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"expected a record for "}}]},{"function":40,"kind":"call","operands":[{"kind":"var","name":5}]}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":", found "}}]}]},{"function":40,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}]},{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":7,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"bound":{"function":5,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"duplicate record for "}}]},{"function":40,"kind":"call","operands":[{"index":0,"kind":"field","value":{"kind":"var","name":1}}]}]},{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}]},"kind":"let","name":6,"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"bound":{"arms":[{"binders":[4],"body":{"kind":"var","name":4},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"index":2,"kind":"field","value":{"kind":"var","name":1}},"type":{"kind":"bytes"}},"kind":"let","name":5,"type":{"kind":"bytes"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"error":{"index":0,"kind":"adt"},"kind":"result","ok":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},{"index":2,"kind":"adt"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":27,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":2,"kind":"adt"}],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"index":2,"kind":"adt"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"index":2,"kind":"adt"},"kind":"list"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"index":2,"kind":"adt"}]},{"body":{"body":{"condition":{"function":42,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}}}},"bound":{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":43,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"constructor":1,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"function":31,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":3}]},"shape":{"kind":"error"}},{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"first","value":{"kind":"var","name":5}},{"kind":"second","value":{"kind":"var","name":5}},{"kind":"var","name":3}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":2,"kind":"adt"}},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"index":2,"kind":"adt"},"kind":"list"}},{"function":45,"kind":"call","operands":[{"kind":"var","name":1}]}],"shape":{"constructor":0,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"function":44,"kind":"call","operands":[{"kind":"var","name":2}]},"type":{"index":1,"kind":"adt"}}},"parameters":[0,1,2,3],"result":{"index":1,"kind":"adt"},"types":[{"element":{"index":2,"kind":"adt"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"kind":"build","operands":[{"function":19,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"shape":{"constructor":2,"kind":"adt"},"type":{"index":1,"kind":"adt"}},"parameters":[0,1],"result":{"index":1,"kind":"adt"},"types":[{"kind":"bytes"},{"kind":"option","value":{"kind":"bytes"}}]},{"body":{"body":{"body":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"nat_sub"}}]},"bound":{"function":47,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"kind":"let","name":2,"type":{"kind":"nat"}},"bound":{"function":46,"kind":"call","operands":[{"kind":"var","name":0}]},"kind":"let","name":1,"type":{"kind":"nat"}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":48,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"'"}}]}]},"else_branch":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":50,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"info: "}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"build","operands":[{"kind":"var","name":1}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":5},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"10"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":52,"kind":"call","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}]},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":4,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":1}}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":1}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":36,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1,2],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"fn","parameters":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}],"result":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":1},{"kind":"var","name":0}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":38,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"nat"}],"result":{"kind":"option","value":{"kind":"nat"}}},{"kind":"nat"},{"kind":"nat"}]},{"body":{"function":53,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"function":6,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"`"}}]},{"kind":"var","name":0}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"`"}}]}]},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":3}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":54,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":3}}]},"else_branch":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":41,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},{"kind":"build","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"},{"element":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}},"kind":"list"}]},{"body":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}],"operation":{"kind":"nat_lt"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" does not depend on any axioms"}}]}]},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"]"}}]}]},"type":{"kind":"bool"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}},{"binders":[1],"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"var","name":4},"kind":"cond","then_branch":{"kind":"var","name":3}},"bound":{"function":59,"kind":"call","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":2}]}]},"kind":"let","name":4,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":58,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"kind":"let","name":3,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"arms":[{"binders":[5],"body":{"function":62,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":5}]},"shape":{"kind":"some"}},{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"]"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":56,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"' does not depend on any axioms"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"'"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}},"shape":{"kind":"nil"}},{"binders":[1,2],"body":{"kind":"var","name":2},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"element":{"kind":"bytes"},"kind":"list"}},"parameters":[0],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":63,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"parameters":[0],"result":{"kind":"nat"},"types":[{"kind":"bytes"}]},{"body":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":64,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}]}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"function":48,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"arms":[{"binders":[2],"body":{"arms":[{"binders":[3],"body":{"body":{"body":{"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":7}},"bound":{"function":66,"kind":"call","operands":[{"kind":"var","name":5},{"kind":"var","name":6}]},"kind":"let","name":7,"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":3}},"kind":"let","name":6,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":3}},"kind":"let","name":5,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":2}},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"index"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"fixed","width":"u8"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":68,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"0d","kind":"bytes"}}]},"else_branch":{"kind":"var","name":0},"kind":"cond","then_branch":{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]}},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"9"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"13"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"32"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"194"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"225"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"226"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"227"}}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"129"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"159"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"138"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"168"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"169"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"175"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"154"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"128"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}}},"kind":"cond","then_branch":{"condition":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"133"}}]},"else_branch":{"condition":{"function":69,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"160"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":68,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"function":59,"kind":"call","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"unrecognized axiom payload: "}}]},{"kind":"var","name":0}]}]},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"kind":"build","operands":[{"kind":"var","name":0}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"}]},{"body":{"function":6,"kind":"call","operands":[{"function":40,"kind":"call","operands":[{"kind":"var","name":0}]},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" is not a Lean name"}}]}]},"parameters":[0],"result":{"kind":"bytes"},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"first","value":{"function":71,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":72,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}]}}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"var","name":6},"kind":"cond","then_branch":{"kind":"var","name":5}},"bound":{"function":59,"kind":"call","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":3}]}]},"kind":"let","name":6,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":74,"kind":"call","operands":[{"kind":"var","name":3},{"kind":"var","name":4}]},"kind":"let","name":5,"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"second","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"function":57,"kind":"call","operands":[{"kind":"var","name":0}]},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":73,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"' depends on axioms: ["}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_add"}},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"function":75,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":2}]}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}]},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":76,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"body":{"body":{"arms":[{"binders":[5],"body":{"body":{"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":3}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":6}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":8}}}},"bound":{"function":77,"kind":"call","operands":[{"kind":"var","name":7}]},"kind":"let","name":8,"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":5}},"kind":"let","name":7,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":5}},"kind":"let","name":6,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":":"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"bound":{"kind":"second","value":{"kind":"var","name":2}},"kind":"let","name":4,"type":{"kind":"bytes"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"bytes"}},"shape":{"kind":"some"}},{"binders":[],"body":{"body":{"condition":{"function":67,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"kind":"cond","then_branch":{"kind":"var","name":9}},"bound":{"function":77,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":9,"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":65,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"-"}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"function":78,"kind":"call","operands":[{"function":32,"kind":"call","operands":[{"kind":"var","name":0}]}]},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"arms":[{"binders":[4],"body":{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}},{"kind":"var","name":3}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":2}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[4],"body":{"function":79,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":2},{"kind":"var","name":3}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"type":{"kind":"bool"}},"parameters":[0,1,2,3],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"zero"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"none"}},{"binders":[4],"body":{"function":71,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3},{"kind":"var","name":4}]},"shape":{"kind":"some"}}],"kind":"match","scrutinee":{"kind":"apply","operands":[{"kind":"var","name":2}],"target":{"kind":"var","name":0}},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"shape":{"kind":"succ"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}}},"parameters":[0,1,2],"result":{"kind":"pair","left":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}},"right":{"kind":"bool"}},"types":[{"kind":"fn","parameters":[{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},{"kind":"nat"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":80,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":4}]},{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":3}],"operation":{"kind":"nat_add"}}],"operation":{"kind":"nat_sub"}}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}}},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":81,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"operation":{"kind":"nat_sub"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"bytes"},"right":{"kind":"bytes"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[2],"body":{"function":59,"kind":"call","operands":[{"kind":"var","name":2}]},"shape":{"kind":"error"}},{"binders":[3],"body":{"arms":[{"binders":[],"body":{"function":59,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"an axiom list cannot be empty"}}]}]},"shape":{"kind":"nil"}},{"binders":[4,5],"body":{"function":58,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":3},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"function":83,"kind":"call","operands":[{"captures":[],"function":84,"kind":"closure"},{"kind":"build","operands":[{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},{"function":85,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"44"}}]}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"kind":"pair","left":{"kind":"bytes"},"right":{"element":{"kind":"bytes"},"kind":"list"}}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},{"kind":"var","name":1}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}}},"else_branch":{"condition":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}},{"kind":"var","name":1}],"operation":{"kind":"nat_le"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"function":55,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_sub"}}]},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}],"operation":{"kind":"nat_eq"}}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"3"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"body":{"body":{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"var","name":4}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"bound":{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":3},{"kind":"var","name":0},{"kind":"var","name":2}],"function":86,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}},"kind":"let","name":3,"type":{"kind":"nat"}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"}]},{"body":{"arms":[{"binders":[1],"body":{"function":49,"kind":"call","operands":[{"kind":"var","name":1},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"info: "}}]}]},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"bytes"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":" "}}]}]},"type":{"kind":"option","value":{"kind":"bytes"}}},"parameters":[0],"result":{"kind":"option","value":{"kind":"bytes"}},"types":[{"kind":"bytes"}]},{"body":{"body":{"body":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"prim","operands":[{"kind":"var","name":2}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"condition":{"function":88,"kind":"call","operands":[{"kind":"var","name":2}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"var","name":3}}},"bound":{"function":87,"kind":"call","operands":[{"function":20,"kind":"call","operands":[{"kind":"var","name":2}]}]},"kind":"let","name":3,"type":{"kind":"bool"}},"bound":{"arms":[{"binders":[1],"body":{"kind":"var","name":1},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"var","name":0},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":49,"kind":"call","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"+"}}]}]},"type":{"kind":"bytes"}},"kind":"let","name":2,"type":{"kind":"bytes"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"arms":[{"binders":[3],"body":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":0}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":1}],"operation":{"kind":"checked_sub"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"arms":[{"binders":[2],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"first","value":{"kind":"var","name":1}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"function":89,"kind":"call","operands":[{"kind":"second","value":{"kind":"var","name":1}},{"kind":"var","name":2}]}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"first","value":{"kind":"var","name":1}}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}},"types":[{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"nat"}}]},{"body":{"function":90,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[3],"body":{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2},{"kind":"prim","operands":[{"kind":"var","name":1}],"operation":{"kind":"length"}}],"operation":{"kind":"slice"}},"type":{"kind":"bool"}},"parameters":[0,1,2],"result":{"kind":"bool"},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"var","name":1},"shape":{"kind":"nil"}},{"binders":[3,4],"body":{"function":83,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"apply","operands":[{"kind":"var","name":1},{"kind":"var","name":3}],"target":{"kind":"var","name":0}},{"kind":"var","name":4}]},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":2},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1,2],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"kind":"fn","parameters":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"function":91,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}]},{"body":{"body":{"body":{"body":{"function":17,"kind":"call","operands":[{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":3}}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}]},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":3}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"function":15,"kind":"call","operands":[{"captures":[{"kind":"var","name":1},{"kind":"var","name":0}],"function":92,"kind":"closure"},{"kind":"var","name":2},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}]}},"kind":"let","name":3,"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},"kind":"let","name":2,"type":{"kind":"nat"}},"parameters":[0,1],"result":{"element":{"kind":"bytes"},"kind":"list"},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":2},{"kind":"var","name":0},{"kind":"var","name":4}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"var","name":1}],"operation":{"kind":"nat_add"}},{"kind":"var","name":3}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":4},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2,3,4],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"},{"kind":"bytes"},{"kind":"nat"},{"kind":"nat"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_lt"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"20"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"false"},"type":{"kind":"bool"}},"kind":"cond","then_branch":{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"prim","operands":[{"kind":"var","name":0},{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"18446744073709551615"}}]}],"operation":{"kind":"compare_bytes"}},{"kind":"prim","operands":[{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"01","kind":"bytes"}},{"kind":"value","type":{"kind":"bytes"},"value":{"hex":"00","kind":"bytes"}}],"operation":{"kind":"compare_bytes"}}],"operation":{"kind":"equal"}}],"operation":{"kind":"bool_not"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"kind":"prim","operands":[{"kind":"first","value":{"function":38,"kind":"call","operands":[{"captures":[{"kind":"var","name":0}],"function":93,"kind":"closure"},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}]}},{"kind":"prim","operands":[{"kind":"var","name":0}],"operation":{"kind":"length"}}],"operation":{"kind":"nat_eq"}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"bytes"}]},{"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"46"}}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":94,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"condition":{"function":95,"kind":"call","operands":[{"kind":"var","name":1}]},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}},"kind":"cond","then_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_eq"}},"else_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}}}},"kind":"cond","then_branch":{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"2"}}},"parameters":[0,1],"result":{"kind":"nat"},"types":[{"kind":"nat"},{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":82,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"var","name":2}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"0"}},{"kind":"var","name":2}],"operation":{"kind":"nat_lt"}},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":2},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_sub"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"bytes"},{"kind":"nat"}]},{"body":{"arms":[{"binders":[2],"body":{"kind":"var","name":0},"shape":{"kind":"error"}},{"binders":[3],"body":{"body":{"condition":{"function":61,"kind":"call","operands":[{"kind":"var","name":4}]},"else_branch":{"kind":"build","operands":[{"function":60,"kind":"call","operands":[{"kind":"var","name":4}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"kind":"cond","then_branch":{"arms":[{"binders":[5],"body":{"kind":"build","operands":[{"kind":"var","name":5}],"shape":{"kind":"ok"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[{"function":6,"kind":"call","operands":[{"function":7,"kind":"call","operands":[{"kind":"value","type":{"kind":"string"},"value":{"kind":"string","value":"duplicate axiom name "}}]},{"function":40,"kind":"call","operands":[{"kind":"var","name":4}]}]}],"shape":{"kind":"error"},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":96,"kind":"call","operands":[{"kind":"var","name":4},{"kind":"var","name":3}]},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}}},"bound":{"function":32,"kind":"call","operands":[{"kind":"var","name":1}]},"kind":"let","name":4,"type":{"kind":"bytes"}},"shape":{"kind":"ok"}}],"kind":"match","scrutinee":{"kind":"var","name":0},"type":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1],"result":{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"error":{"kind":"bytes"},"kind":"result","ok":{"element":{"kind":"bytes"},"kind":"list"}},{"kind":"bytes"}]},{"body":{"function":97,"kind":"call","operands":[{"kind":"var","name":1},{"kind":"var","name":0},{"kind":"var","name":2}]},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"fixed","width":"u8"},{"kind":"bytes"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"function":98,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1}]},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]},{"body":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"65"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"90"}}]},"else_branch":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"97"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"122"}}]},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"95"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"condition":{"function":94,"kind":"call","operands":[{"kind":"var","name":0}]},"else_branch":{"condition":{"function":79,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"63"}}],"operation":{"kind":"equal"}},"else_branch":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"39"}}],"operation":{"kind":"equal"}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"true"},"type":{"kind":"bool"}}},"parameters":[0],"result":{"kind":"bool"},"types":[{"kind":"fixed","width":"u8"}]},{"body":{"arms":[{"binders":[],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[],"shape":{"kind":"nil"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"nil"}},{"binders":[2,3],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":0},{"kind":"var","name":2}],"operation":{"kind":"equal"}},"else_branch":{"condition":{"function":54,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":2}]},"else_branch":{"arms":[{"binders":[4],"body":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":4}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":96,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"var","name":0},{"kind":"build","operands":[{"kind":"var","name":2},{"kind":"var","name":3}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}}},"kind":"cond","then_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}}},"shape":{"kind":"cons"}}],"kind":"match","scrutinee":{"kind":"var","name":1},"type":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}}},"parameters":[0,1],"result":{"kind":"option","value":{"element":{"kind":"bytes"},"kind":"list"}},"types":[{"kind":"bytes"},{"element":{"kind":"bytes"},"kind":"list"}]},{"body":{"body":{"body":{"body":{"arms":[{"binders":[6],"body":{"condition":{"kind":"prim","operands":[{"kind":"var","name":6},{"kind":"var","name":1}],"operation":{"kind":"equal"}},"else_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"var","name":4},{"kind":"var","name":5}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}},{"kind":"build","operands":[{"function":18,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":4},{"kind":"prim","operands":[{"kind":"var","name":3},{"kind":"var","name":4}],"operation":{"kind":"nat_sub"}}]},{"kind":"var","name":5}],"shape":{"kind":"cons"},"type":{"element":{"kind":"bytes"},"kind":"list"}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}],"shape":{"kind":"pair"},"type":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}}},"shape":{"kind":"some"}},{"binders":[],"body":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"shape":{"kind":"none"}}],"kind":"match","scrutinee":{"function":51,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":3}]},"type":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}}},"bound":{"kind":"second","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":5,"type":{"element":{"kind":"bytes"},"kind":"list"}},"bound":{"kind":"first","value":{"kind":"second","value":{"kind":"var","name":2}}},"kind":"let","name":4,"type":{"kind":"nat"}},"bound":{"kind":"first","value":{"kind":"var","name":2}},"kind":"let","name":3,"type":{"kind":"nat"}},"parameters":[0,1,2],"result":{"kind":"option","value":{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}},"types":[{"kind":"bytes"},{"kind":"fixed","width":"u8"},{"kind":"pair","left":{"kind":"nat"},"right":{"kind":"pair","left":{"kind":"nat"},"right":{"element":{"kind":"bytes"},"kind":"list"}}}]},{"body":{"condition":{"function":70,"kind":"call","operands":[{"kind":"var","name":0},{"kind":"var","name":1},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"48"}},{"kind":"value","type":{"kind":"fixed","width":"u8"},"value":{"kind":"u8","value":"57"}}]},"else_branch":{"kind":"build","operands":[],"shape":{"kind":"none"},"type":{"kind":"option","value":{"kind":"nat"}}},"kind":"cond","then_branch":{"kind":"build","operands":[{"kind":"prim","operands":[{"kind":"var","name":1},{"kind":"value","type":{"kind":"nat"},"value":{"kind":"nat","value":"1"}}],"operation":{"kind":"nat_add"}}],"shape":{"kind":"some"},"type":{"kind":"option","value":{"kind":"nat"}}}},"parameters":[0,1],"result":{"kind":"option","value":{"kind":"nat"}},"types":[{"kind":"bytes"},{"kind":"nat"}]}],"spec":"lexlean/target-program/1"},"sources":["5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48"],"spec":"lexlean/rust-package/1","version":"1.0.0"} diff --git a/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/provenance.json b/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/provenance.json index 3027659e1..45d4b8569 100644 --- a/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/provenance.json +++ b/tests/production-export/bootstrap/packages/rust-std/parse_audit_output/provenance.json @@ -1 +1 @@ -{"compiler_semantics":"7a7834c67571071b41d4390091dc975814669691047856199bec9267687cd9b0","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3749ba61adbd9860c5e44e0d360637f984f5f53e471383285a44ea9b476828ac","src/lib.rs":"750867c70a608915dbc1dd0648b81ae04f2c15727e9f6355a4604d00c44d9e5b"},"name":"parse_audit_output","profile":"rust-std","program":"c494532214aa6b635eeb3efaed879328a4f5370efdc9d5079105c177d5f4ede8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["adb40bbfc73b1dc6b7a95dab0c348a2752ede8bc8cffbc4bfb49bce333d9aceb"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} +{"compiler_semantics":"91b3cb51013515a91251eb57e00451e091cc1d5aec5336ad436a223fec0b8e2a","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"3749ba61adbd9860c5e44e0d360637f984f5f53e471383285a44ea9b476828ac","src/lib.rs":"750867c70a608915dbc1dd0648b81ae04f2c15727e9f6355a4604d00c44d9e5b"},"name":"parse_audit_output","profile":"rust-std","program":"c494532214aa6b635eeb3efaed879328a4f5370efdc9d5079105c177d5f4ede8","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["5ba510b7049a3e59c5f1ffb1f0a6611dd35ecbdb9904f2d3213052229b253f48"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} From f73831082f1acd4177019ec9f2d4b62f6bf759a7 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 08:25:03 +0000 Subject: [PATCH 6/6] docs(packages): the README capability table claims PK-01..PK-04 (RP-11) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01AinddrUH9xHeNmR6FTWypN --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8ac75618d..b15e44d90 100644 --- a/README.md +++ b/README.md @@ -184,6 +184,7 @@ Every row is validated by `just vv`; the IDs link the claim to its register row, | The runtime of generated Lean as native modules: the portable, collection, model, and reasoning runtimes of language 1.2 are LexLean source that every generated module imports, migrated losslessly and audited against their exact axioms, the released runtime text of languages 1.0 and 1.1 is frozen data equal to their released output, and no other Lean runtime text remains in the compiler but the decoder of core module 2 | `RT-01`..`RT-04` | `build` | | The standard library: language-1.2 source beside the compiler whose members are certified production roots, each validated against Rust's standard library by a seeded differential of its evaluator and rustc realizations; bytes and text over `Bytes` | `SL-01` | `build` | | The bootstrap project: the compiler's own components as language-1.2 source compiled by LexLean's production pipeline to certified Rust packages, the first being the exact axiom-output parser and its closed Lean-name check, each held to the Rust it replaces (the stage-0 oracle) by the committed golden vectors and a seeded differential of its evaluator and rustc realizations, with planted defects detected and the production export committed | `BS-01` | `build` | +| Source packages: a language-1.2 project imports the modules of a locked, content-addressed package of its workspace: `[[source_package]]` and `lexlean-workspace.toml`, the pins in `lexlean.lock` recomputed by every command, imports closed at link, no re-export of a package's production roots, and the package's modules replayed by the importer's `verify` with their origin in the records | `PK-01`..`PK-04` | `build` | | The literal `nat-add-zero` example, the Lean-verified feature examples, and the complete negative fixture suite | `EX-01`..`EX-08` | `build` | | Language-1.2 text components, first slice: tokenizers and their round-trip laws, with the laws carried as one native core module the generated modules import rather than authored Lean text (context windows, text generators, text classifiers, adapters, and composition follow in their own slices and add their rows then) | `LM-01`, `LM-02`, `LM-03`, `LM-13` | `build` |